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 Transform feedback tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es3fTransformFeedbackTests.hpp" 25 #include "tcuTestLog.hpp" 26 #include "tcuSurface.hpp" 27 #include "tcuImageCompare.hpp" 28 #include "tcuVector.hpp" 29 #include "tcuFormatUtil.hpp" 30 #include "tcuRenderTarget.hpp" 31 #include "gluShaderUtil.hpp" 32 #include "gluVarType.hpp" 33 #include "gluVarTypeUtil.hpp" 34 #include "gluPixelTransfer.hpp" 35 #include "gluRenderContext.hpp" 36 #include "gluShaderProgram.hpp" 37 #include "gluObjectWrapper.hpp" 38 #include "glwFunctions.hpp" 39 #include "glwEnums.hpp" 40 #include "deRandom.hpp" 41 #include "deStringUtil.hpp" 42 #include "deMemory.h" 43 #include "deString.h" 44 45 #include <set> 46 #include <map> 47 #include <algorithm> 48 49 using std::string; 50 using std::vector; 51 using std::set; 52 53 using std::map; 54 using std::set; 55 56 using tcu::TestLog; 57 58 namespace deqp 59 { 60 namespace gles3 61 { 62 namespace Functional 63 { 64 namespace TransformFeedback 65 { 66 67 enum 68 { 69 VIEWPORT_WIDTH = 128, 70 VIEWPORT_HEIGHT = 128, 71 BUFFER_GUARD_MULTIPLIER = 2 //!< stride*BUFFER_GUARD_MULTIPLIER bytes are added to the end of tf buffer and used to check for overruns. 72 }; 73 74 enum Interpolation 75 { 76 INTERPOLATION_SMOOTH = 0, 77 INTERPOLATION_FLAT, 78 INTERPOLATION_CENTROID, 79 80 INTERPOLATION_LAST 81 }; 82 83 static const char* getInterpolationName (Interpolation interp) 84 { 85 switch (interp) 86 { 87 case INTERPOLATION_SMOOTH: return "smooth"; 88 case INTERPOLATION_FLAT: return "flat"; 89 case INTERPOLATION_CENTROID: return "centroid"; 90 default: 91 DE_ASSERT(false); 92 return DE_NULL; 93 } 94 } 95 96 struct Varying 97 { 98 Varying (const char* name_, const glu::VarType& type_, Interpolation interp_) 99 : name (name_) 100 , type (type_) 101 , interpolation (interp_) 102 { 103 } 104 105 std::string name; //!< Variable name. 106 glu::VarType type; //!< Variable type. 107 Interpolation interpolation; //!< Interpolation mode (smooth, flat, centroid). 108 }; 109 110 struct VaryingNameEquals 111 { 112 VaryingNameEquals (const std::string& name_) : name(name_) {} 113 bool operator() (const Varying& var) const { return var.name == name; } 114 115 std::string name; 116 }; 117 118 struct Attribute 119 { 120 Attribute (const std::string& name_, const glu::VarType& type_, int offset_) 121 : name (name_) 122 , type (type_) 123 , offset (offset_) 124 { 125 } 126 127 std::string name; 128 glu::VarType type; 129 int offset; 130 }; 131 132 struct AttributeNameEquals 133 { 134 AttributeNameEquals (const std::string& name_) : name(name_) {} 135 bool operator() (const Attribute& attr) const { return attr.name == name; } 136 137 std::string name; 138 }; 139 140 struct Output 141 { 142 Output (void) 143 : bufferNdx (0) 144 , offset (0) 145 { 146 } 147 148 std::string name; 149 glu::VarType type; 150 int bufferNdx; 151 int offset; 152 vector<const Attribute*> inputs; 153 }; 154 155 struct DrawCall 156 { 157 DrawCall (int numElements_, bool tfEnabled_) 158 : numElements (numElements_) 159 , transformFeedbackEnabled (tfEnabled_) 160 { 161 } 162 163 DrawCall (void) 164 : numElements (0) 165 , transformFeedbackEnabled (false) 166 { 167 } 168 169 int numElements; 170 bool transformFeedbackEnabled; 171 }; 172 173 std::ostream& operator<< (std::ostream& str, const DrawCall& call) 174 { 175 return str << "(" << call.numElements << ", " << (call.transformFeedbackEnabled ? "resumed" : "paused") << ")"; 176 } 177 178 class ProgramSpec 179 { 180 public: 181 ProgramSpec (void); 182 ~ProgramSpec (void); 183 184 glu::StructType* createStruct (const char* name); 185 void addVarying (const char* name, const glu::VarType& type, Interpolation interp); 186 void addTransformFeedbackVarying (const char* name); 187 188 const vector<glu::StructType*>& getStructs (void) const { return m_structs; } 189 const vector<Varying>& getVaryings (void) const { return m_varyings; } 190 const vector<string>& getTransformFeedbackVaryings (void) const { return m_transformFeedbackVaryings; } 191 bool isPointSizeUsed (void) const; 192 193 private: 194 ProgramSpec (const ProgramSpec& other); 195 ProgramSpec& operator= (const ProgramSpec& other); 196 197 vector<glu::StructType*> m_structs; 198 vector<Varying> m_varyings; 199 vector<string> m_transformFeedbackVaryings; 200 }; 201 202 // ProgramSpec 203 204 ProgramSpec::ProgramSpec (void) 205 { 206 } 207 208 ProgramSpec::~ProgramSpec (void) 209 { 210 for (vector<glu::StructType*>::iterator i = m_structs.begin(); i != m_structs.end(); i++) 211 delete *i; 212 } 213 214 glu::StructType* ProgramSpec::createStruct (const char* name) 215 { 216 m_structs.reserve(m_structs.size()+1); 217 m_structs.push_back(new glu::StructType(name)); 218 return m_structs.back(); 219 } 220 221 void ProgramSpec::addVarying (const char* name, const glu::VarType& type, Interpolation interp) 222 { 223 m_varyings.push_back(Varying(name, type, interp)); 224 } 225 226 void ProgramSpec::addTransformFeedbackVarying (const char* name) 227 { 228 m_transformFeedbackVaryings.push_back(name); 229 } 230 231 bool ProgramSpec::isPointSizeUsed (void) const 232 { 233 return std::find(m_transformFeedbackVaryings.begin(), m_transformFeedbackVaryings.end(), "gl_PointSize") != m_transformFeedbackVaryings.end(); 234 } 235 236 static bool isProgramSupported (const glw::Functions& gl, const ProgramSpec& spec, deUint32 tfMode) 237 { 238 int maxVertexAttribs = 0; 239 int maxTfInterleavedComponents = 0; 240 int maxTfSeparateAttribs = 0; 241 int maxTfSeparateComponents = 0; 242 243 gl.getIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs); 244 gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, &maxTfInterleavedComponents); 245 gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTfSeparateAttribs); 246 gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, &maxTfSeparateComponents); 247 248 // Check vertex attribs. 249 int totalVertexAttribs = 1 /* a_position */ + (spec.isPointSizeUsed() ? 1 : 0); 250 for (vector<Varying>::const_iterator var = spec.getVaryings().begin(); var != spec.getVaryings().end(); var++) 251 { 252 for (glu::VectorTypeIterator vecIter = glu::VectorTypeIterator::begin(&var->type); vecIter != glu::VectorTypeIterator::end(&var->type); vecIter++) 253 totalVertexAttribs += 1; 254 } 255 256 if (totalVertexAttribs > maxVertexAttribs) 257 return false; // Vertex attribute count exceeded. 258 259 // Check varyings. 260 int totalTfComponents = 0; 261 int totalTfAttribs = 0; 262 for (vector<string>::const_iterator iter = spec.getTransformFeedbackVaryings().begin(); iter != spec.getTransformFeedbackVaryings().end(); iter++) 263 { 264 const string& name = *iter; 265 int numComponents = 0; 266 267 if (name == "gl_Position") 268 numComponents = 4; 269 else if (name == "gl_PointSize") 270 numComponents = 1; 271 else 272 { 273 string varName = glu::parseVariableName(name.c_str()); 274 const Varying& varying = *std::find_if(spec.getVaryings().begin(), spec.getVaryings().end(), VaryingNameEquals(varName)); 275 glu::TypeComponentVector varPath; 276 277 glu::parseTypePath(name.c_str(), varying.type, varPath); 278 numComponents = glu::getVarType(varying.type, varPath).getScalarSize(); 279 } 280 281 if (tfMode == GL_SEPARATE_ATTRIBS && numComponents > maxTfSeparateComponents) 282 return false; // Per-attribute component count exceeded. 283 284 totalTfComponents += numComponents; 285 totalTfAttribs += 1; 286 } 287 288 if (tfMode == GL_SEPARATE_ATTRIBS && totalTfAttribs > maxTfSeparateAttribs) 289 return false; 290 291 if (tfMode == GL_INTERLEAVED_ATTRIBS && totalTfComponents > maxTfInterleavedComponents) 292 return false; 293 294 return true; 295 } 296 297 // Program 298 299 static std::string getAttributeName (const char* varyingName, const glu::TypeComponentVector& path) 300 { 301 std::ostringstream str; 302 303 str << "a_" << (deStringBeginsWith(varyingName, "v_") ? varyingName+2 : varyingName); 304 305 for (glu::TypeComponentVector::const_iterator iter = path.begin(); iter != path.end(); iter++) 306 { 307 const char* prefix = DE_NULL; 308 309 switch (iter->type) 310 { 311 case glu::VarTypeComponent::STRUCT_MEMBER: prefix = "_m"; break; 312 case glu::VarTypeComponent::ARRAY_ELEMENT: prefix = "_e"; break; 313 case glu::VarTypeComponent::MATRIX_COLUMN: prefix = "_c"; break; 314 case glu::VarTypeComponent::VECTOR_COMPONENT: prefix = "_s"; break; 315 default: 316 DE_ASSERT(false); 317 } 318 319 str << prefix << iter->index; 320 } 321 322 return str.str(); 323 } 324 325 static void genShaderSources (const ProgramSpec& spec, std::string& vertSource, std::string& fragSource, bool pointSizeRequired) 326 { 327 std::ostringstream vtx; 328 std::ostringstream frag; 329 bool addPointSize = spec.isPointSizeUsed(); 330 331 vtx << "#version 300 es\n" 332 << "in highp vec4 a_position;\n"; 333 frag << "#version 300 es\n" 334 << "layout(location = 0) out mediump vec4 o_color;\n" 335 << "uniform highp vec4 u_scale;\n" 336 << "uniform highp vec4 u_bias;\n"; 337 338 if (addPointSize) 339 vtx << "in highp float a_pointSize;\n"; 340 341 // Declare attributes. 342 for (vector<Varying>::const_iterator var = spec.getVaryings().begin(); var != spec.getVaryings().end(); var++) 343 { 344 const char* name = var->name.c_str(); 345 const glu::VarType& type = var->type; 346 347 for (glu::VectorTypeIterator vecIter = glu::VectorTypeIterator::begin(&type); vecIter != glu::VectorTypeIterator::end(&type); vecIter++) 348 { 349 glu::VarType attribType = glu::getVarType(type, vecIter.getPath()); 350 string attribName = getAttributeName(name, vecIter.getPath()); 351 352 vtx << "in " << glu::declare(attribType, attribName.c_str()) << ";\n"; 353 } 354 } 355 356 // Declare vayrings. 357 for (int ndx = 0; ndx < 2; ndx++) 358 { 359 const char* inout = ndx ? "in" : "out"; 360 std::ostringstream& str = ndx ? frag : vtx; 361 362 // Declare structs that have type name. 363 for (vector<glu::StructType*>::const_iterator structIter = spec.getStructs().begin(); structIter != spec.getStructs().end(); structIter++) 364 { 365 const glu::StructType* structPtr = *structIter; 366 if (structPtr->hasTypeName()) 367 str << glu::declare(structPtr) << ";\n"; 368 } 369 370 for (vector<Varying>::const_iterator var = spec.getVaryings().begin(); var != spec.getVaryings().end(); var++) 371 str << getInterpolationName(var->interpolation) << " " << inout << " " << glu::declare(var->type, var->name.c_str()) << ";\n"; 372 } 373 374 vtx << "\nvoid main (void)\n{\n" 375 << "\tgl_Position = a_position;\n"; 376 frag << "\nvoid main (void)\n{\n" 377 << "\thighp vec4 res = vec4(0.0);\n"; 378 379 if (addPointSize) 380 vtx << "\tgl_PointSize = a_pointSize;\n"; 381 else if (pointSizeRequired) 382 vtx << "\tgl_PointSize = 1.0;\n"; 383 384 // Generate assignments / usage. 385 for (vector<Varying>::const_iterator var = spec.getVaryings().begin(); var != spec.getVaryings().end(); var++) 386 { 387 const char* name = var->name.c_str(); 388 const glu::VarType& type = var->type; 389 390 for (glu::VectorTypeIterator vecIter = glu::VectorTypeIterator::begin(&type); vecIter != glu::VectorTypeIterator::end(&type); vecIter++) 391 { 392 glu::VarType subType = glu::getVarType(type, vecIter.getPath()); 393 string attribName = getAttributeName(name, vecIter.getPath()); 394 395 DE_ASSERT(subType.isBasicType() && glu::isDataTypeScalarOrVector(subType.getBasicType())); 396 397 // Vertex: assign from attribute. 398 vtx << "\t" << name << vecIter << " = " << attribName << ";\n"; 399 400 // Fragment: add to res variable. 401 int scalarSize = glu::getDataTypeScalarSize(subType.getBasicType()); 402 403 frag << "\tres += "; 404 if (scalarSize == 1) frag << "vec4(" << name << vecIter << ")"; 405 else if (scalarSize == 2) frag << "vec2(" << name << vecIter << ").xxyy"; 406 else if (scalarSize == 3) frag << "vec3(" << name << vecIter << ").xyzx"; 407 else if (scalarSize == 4) frag << "vec4(" << name << vecIter << ")"; 408 409 frag << ";\n"; 410 } 411 } 412 413 frag << "\to_color = res * u_scale + u_bias;\n"; 414 415 vtx << "}\n"; 416 frag << "}\n"; 417 418 vertSource = vtx.str(); 419 fragSource = frag.str(); 420 } 421 422 static glu::ShaderProgram* createVertexCaptureProgram (const glu::RenderContext& context, const ProgramSpec& spec, deUint32 bufferMode, deUint32 primitiveType) 423 { 424 std::string vertSource, fragSource; 425 426 genShaderSources(spec, vertSource, fragSource, primitiveType == GL_POINTS /* Is point size required? */); 427 428 return new glu::ShaderProgram(context, glu::ProgramSources() 429 << glu::VertexSource(vertSource) 430 << glu::FragmentSource(fragSource) 431 << glu::TransformFeedbackVaryings<vector<string>::const_iterator>(spec.getTransformFeedbackVaryings().begin(), spec.getTransformFeedbackVaryings().end()) 432 << glu::TransformFeedbackMode(bufferMode)); 433 } 434 435 // Helpers. 436 437 static void computeInputLayout (vector<Attribute>& attributes, int& inputStride, const vector<Varying>& varyings, bool usePointSize) 438 { 439 inputStride = 0; 440 441 // Add position. 442 attributes.push_back(Attribute("a_position", glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), inputStride)); 443 inputStride += 4*sizeof(deUint32); 444 445 if (usePointSize) 446 { 447 attributes.push_back(Attribute("a_pointSize", glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), inputStride)); 448 inputStride += 1*sizeof(deUint32); 449 } 450 451 // Compute attribute vector. 452 for (vector<Varying>::const_iterator var = varyings.begin(); var != varyings.end(); var++) 453 { 454 for (glu::VectorTypeIterator vecIter = glu::VectorTypeIterator::begin(&var->type); vecIter != glu::VectorTypeIterator::end(&var->type); vecIter++) 455 { 456 glu::VarType type = vecIter.getType(); 457 string name = getAttributeName(var->name.c_str(), vecIter.getPath()); 458 459 attributes.push_back(Attribute(name, type, inputStride)); 460 inputStride += glu::getDataTypeScalarSize(type.getBasicType())*sizeof(deUint32); 461 } 462 } 463 } 464 465 static void computeTransformFeedbackOutputs (vector<Output>& transformFeedbackOutputs, const vector<Attribute>& attributes, const vector<Varying>& varyings, const vector<string>& transformFeedbackVaryings, deUint32 bufferMode) 466 { 467 int accumulatedSize = 0; 468 469 transformFeedbackOutputs.resize(transformFeedbackVaryings.size()); 470 for (int varNdx = 0; varNdx < (int)transformFeedbackVaryings.size(); varNdx++) 471 { 472 const string& name = transformFeedbackVaryings[varNdx]; 473 int bufNdx = (bufferMode == GL_SEPARATE_ATTRIBS ? varNdx : 0); 474 int offset = (bufferMode == GL_SEPARATE_ATTRIBS ? 0 : accumulatedSize); 475 Output& output = transformFeedbackOutputs[varNdx]; 476 477 output.name = name; 478 output.bufferNdx = bufNdx; 479 output.offset = offset; 480 481 if (name == "gl_Position") 482 { 483 const Attribute* posIn = &(*std::find_if(attributes.begin(), attributes.end(), AttributeNameEquals("a_position"))); 484 output.type = posIn->type; 485 output.inputs.push_back(posIn); 486 } 487 else if (name == "gl_PointSize") 488 { 489 const Attribute* sizeIn = &(*std::find_if(attributes.begin(), attributes.end(), AttributeNameEquals("a_pointSize"))); 490 output.type = sizeIn->type; 491 output.inputs.push_back(sizeIn); 492 } 493 else 494 { 495 string varName = glu::parseVariableName(name.c_str()); 496 const Varying& varying = *std::find_if(varyings.begin(), varyings.end(), VaryingNameEquals(varName)); 497 glu::TypeComponentVector varPath; 498 499 glu::parseTypePath(name.c_str(), varying.type, varPath); 500 501 output.type = glu::getVarType(varying.type, varPath); 502 503 // Add all vectorized attributes as inputs. 504 for (glu::VectorTypeIterator iter = glu::VectorTypeIterator::begin(&output.type); iter != glu::VectorTypeIterator::end(&output.type); iter++) 505 { 506 // Full path. 507 glu::TypeComponentVector fullPath(varPath.size() + iter.getPath().size()); 508 509 std::copy(varPath.begin(), varPath.end(), fullPath.begin()); 510 std::copy(iter.getPath().begin(), iter.getPath().end(), fullPath.begin()+varPath.size()); 511 512 string attribName = getAttributeName(varName.c_str(), fullPath); 513 const Attribute* attrib = &(*std::find_if(attributes.begin(), attributes.end(), AttributeNameEquals(attribName))); 514 515 output.inputs.push_back(attrib); 516 } 517 } 518 519 accumulatedSize += output.type.getScalarSize()*sizeof(deUint32); 520 } 521 } 522 523 static deUint32 signExtend (deUint32 value, deUint32 numBits) 524 { 525 DE_ASSERT(numBits >= 1u && numBits <= 32u); 526 if (numBits == 32u) 527 return value; 528 else if ((value & (1u << (numBits-1u))) == 0u) 529 return value; 530 else 531 return value | ~((1u << numBits) - 1u); 532 } 533 534 static void genAttributeData (const Attribute& attrib, deUint8* basePtr, int stride, int numElements, de::Random& rnd) 535 { 536 const int elementSize = (int)sizeof(deUint32); 537 const bool isFloat = glu::isDataTypeFloatOrVec(attrib.type.getBasicType()); 538 const bool isInt = glu::isDataTypeIntOrIVec(attrib.type.getBasicType()); 539 const bool isUint = glu::isDataTypeUintOrUVec(attrib.type.getBasicType()); 540 const glu::Precision precision = attrib.type.getPrecision(); 541 const int numComps = glu::getDataTypeScalarSize(attrib.type.getBasicType()); 542 543 for (int elemNdx = 0; elemNdx < numElements; elemNdx++) 544 { 545 for (int compNdx = 0; compNdx < numComps; compNdx++) 546 { 547 int offset = attrib.offset+elemNdx*stride+compNdx*elementSize; 548 if (isFloat) 549 { 550 float* comp = (float*)(basePtr+offset); 551 switch (precision) 552 { 553 case glu::PRECISION_LOWP: *comp = 0.0f + 0.25f*(float)rnd.getInt(0, 4); break; 554 case glu::PRECISION_MEDIUMP: *comp = rnd.getFloat(-1e3f, 1e3f); break; 555 case glu::PRECISION_HIGHP: *comp = rnd.getFloat(-1e5f, 1e5f); break; 556 default: 557 DE_ASSERT(false); 558 } 559 } 560 else if (isInt) 561 { 562 int* comp = (int*)(basePtr+offset); 563 switch (precision) 564 { 565 case glu::PRECISION_LOWP: *comp = (int)signExtend(rnd.getUint32()&0xff, 8); break; 566 case glu::PRECISION_MEDIUMP: *comp = (int)signExtend(rnd.getUint32()&0xffff, 16); break; 567 case glu::PRECISION_HIGHP: *comp = (int)rnd.getUint32(); break; 568 default: 569 DE_ASSERT(false); 570 } 571 } 572 else if (isUint) 573 { 574 deUint32* comp = (deUint32*)(basePtr+offset); 575 switch (precision) 576 { 577 case glu::PRECISION_LOWP: *comp = rnd.getUint32()&0xff; break; 578 case glu::PRECISION_MEDIUMP: *comp = rnd.getUint32()&0xffff; break; 579 case glu::PRECISION_HIGHP: *comp = rnd.getUint32(); break; 580 default: 581 DE_ASSERT(false); 582 } 583 } 584 else 585 DE_ASSERT(false); 586 } 587 } 588 } 589 590 static void genInputData (const vector<Attribute>& attributes, int numInputs, int inputStride, deUint8* inputBasePtr, de::Random& rnd) 591 { 592 // Random positions. 593 const Attribute& position = *std::find_if(attributes.begin(), attributes.end(), AttributeNameEquals("a_position")); 594 595 for (int ndx = 0; ndx < numInputs; ndx++) 596 { 597 deUint8* ptr = inputBasePtr + position.offset + inputStride*ndx; 598 *((float*)(ptr+ 0)) = rnd.getFloat(-1.2f, 1.2f); 599 *((float*)(ptr+ 4)) = rnd.getFloat(-1.2f, 1.2f); 600 *((float*)(ptr+ 8)) = rnd.getFloat(-1.2f, 1.2f); 601 *((float*)(ptr+12)) = rnd.getFloat(0.1f, 2.0f); 602 } 603 604 // Point size. 605 vector<Attribute>::const_iterator pointSizePos = std::find_if(attributes.begin(), attributes.end(), AttributeNameEquals("a_pointSize")); 606 if (pointSizePos != attributes.end()) 607 { 608 for (int ndx = 0; ndx < numInputs; ndx++) 609 { 610 deUint8* ptr = inputBasePtr + pointSizePos->offset + inputStride*ndx; 611 *((float*)ptr) = rnd.getFloat(1.0f, 8.0f); 612 } 613 } 614 615 // Random data for rest of components. 616 for (vector<Attribute>::const_iterator attrib = attributes.begin(); attrib != attributes.end(); attrib++) 617 { 618 if (attrib->name == "a_position" || attrib->name == "a_pointSize") 619 continue; 620 621 genAttributeData(*attrib, inputBasePtr, inputStride, numInputs, rnd); 622 } 623 } 624 625 static deUint32 getTransformFeedbackOutputCount (deUint32 primitiveType, int numElements) 626 { 627 switch (primitiveType) 628 { 629 case GL_TRIANGLES: return numElements - numElements%3; 630 case GL_TRIANGLE_STRIP: return de::max(0, numElements-2)*3; 631 case GL_TRIANGLE_FAN: return de::max(0, numElements-2)*3; 632 case GL_LINES: return numElements - numElements%2; 633 case GL_LINE_STRIP: return de::max(0, numElements-1)*2; 634 case GL_LINE_LOOP: return numElements > 1 ? numElements*2 : 0; 635 case GL_POINTS: return numElements; 636 637 default: 638 DE_ASSERT(false); 639 return 0; 640 } 641 } 642 643 static deUint32 getTransformFeedbackPrimitiveCount (deUint32 primitiveType, int numElements) 644 { 645 switch (primitiveType) 646 { 647 case GL_TRIANGLES: return numElements/3; 648 case GL_TRIANGLE_STRIP: return de::max(0, numElements-2); 649 case GL_TRIANGLE_FAN: return de::max(0, numElements-2); 650 case GL_LINES: return numElements/2; 651 case GL_LINE_STRIP: return de::max(0, numElements-1); 652 case GL_LINE_LOOP: return numElements > 1 ? numElements : 0; 653 case GL_POINTS: return numElements; 654 655 default: 656 DE_ASSERT(false); 657 return 0; 658 } 659 } 660 661 static deUint32 getTransformFeedbackPrimitiveMode (deUint32 primitiveType) 662 { 663 switch (primitiveType) 664 { 665 case GL_TRIANGLES: 666 case GL_TRIANGLE_STRIP: 667 case GL_TRIANGLE_FAN: 668 return GL_TRIANGLES; 669 670 case GL_LINES: 671 case GL_LINE_LOOP: 672 case GL_LINE_STRIP: 673 return GL_LINES; 674 675 case GL_POINTS: 676 return GL_POINTS; 677 678 default: 679 DE_ASSERT(false); 680 return 0; 681 } 682 } 683 684 static int getAttributeIndex (deUint32 primitiveType, int numInputs, int outNdx) 685 { 686 switch (primitiveType) 687 { 688 case GL_TRIANGLES: return outNdx; 689 case GL_LINES: return outNdx; 690 case GL_POINTS: return outNdx; 691 692 case GL_TRIANGLE_STRIP: 693 { 694 int triNdx = outNdx/3; 695 int vtxNdx = outNdx%3; 696 return (triNdx%2 != 0 && vtxNdx < 2) ? (triNdx+1-vtxNdx) : (triNdx+vtxNdx); 697 } 698 699 case GL_TRIANGLE_FAN: 700 return (outNdx%3 != 0) ? (outNdx/3 + outNdx%3) : 0; 701 702 case GL_LINE_STRIP: 703 return outNdx/2 + outNdx%2; 704 705 case GL_LINE_LOOP: 706 { 707 int inNdx = outNdx/2 + outNdx%2; 708 return inNdx < numInputs ? inNdx : 0; 709 } 710 711 default: 712 DE_ASSERT(false); 713 return 0; 714 } 715 } 716 717 static bool compareTransformFeedbackOutput (tcu::TestLog& log, deUint32 primitiveType, const Output& output, int numInputs, const deUint8* inBasePtr, int inStride, const deUint8* outBasePtr, int outStride) 718 { 719 bool isOk = true; 720 int outOffset = output.offset; 721 722 for (int attrNdx = 0; attrNdx < (int)output.inputs.size(); attrNdx++) 723 { 724 const Attribute& attribute = *output.inputs[attrNdx]; 725 glu::DataType type = attribute.type.getBasicType(); 726 int numComponents = glu::getDataTypeScalarSize(type); 727 glu::Precision precision = attribute.type.getPrecision(); 728 glu::DataType scalarType = glu::getDataTypeScalarType(type); 729 int numOutputs = getTransformFeedbackOutputCount(primitiveType, numInputs); 730 731 for (int outNdx = 0; outNdx < numOutputs; outNdx++) 732 { 733 int inNdx = getAttributeIndex(primitiveType, numInputs, outNdx); 734 735 for (int compNdx = 0; compNdx < numComponents; compNdx++) 736 { 737 const deUint8* inPtr = inBasePtr + inStride*inNdx + attribute.offset + compNdx*sizeof(deUint32); 738 const deUint8* outPtr = outBasePtr + outStride*outNdx + outOffset + compNdx*sizeof(deUint32); 739 deUint32 inVal = *(const deUint32*)inPtr; 740 deUint32 outVal = *(const deUint32*)outPtr; 741 bool isEqual = false; 742 743 if (scalarType == glu::TYPE_FLOAT) 744 { 745 // ULP comparison is used for highp and mediump. Lowp uses threshold-comparison. 746 switch (precision) 747 { 748 case glu::PRECISION_HIGHP: isEqual = de::abs((int)inVal - (int)outVal) < 2; break; 749 case glu::PRECISION_MEDIUMP: isEqual = de::abs((int)inVal - (int)outVal) < 2+(1<<13); break; 750 case glu::PRECISION_LOWP: 751 { 752 float inF = *(const float*)inPtr; 753 float outF = *(const float*)outPtr; 754 isEqual = de::abs(inF - outF) < 0.1f; 755 break; 756 } 757 default: 758 DE_ASSERT(false); 759 } 760 } 761 else 762 isEqual = (inVal == outVal); // Bit-exact match required for integer types. 763 764 if (!isEqual) 765 { 766 log << TestLog::Message << "Mismatch in " << output.name << " (" << attribute.name << "), output = " << outNdx << ", input = " << inNdx << ", component = " << compNdx << TestLog::EndMessage; 767 isOk = false; 768 break; 769 } 770 } 771 772 if (!isOk) 773 break; 774 } 775 776 if (!isOk) 777 break; 778 779 outOffset += numComponents*sizeof(deUint32); 780 } 781 782 return isOk; 783 } 784 785 static int computeTransformFeedbackPrimitiveCount (deUint32 primitiveType, const DrawCall* first, const DrawCall* end) 786 { 787 int primCount = 0; 788 789 for (const DrawCall* call = first; call != end; ++call) 790 { 791 if (call->transformFeedbackEnabled) 792 primCount += getTransformFeedbackPrimitiveCount(primitiveType, call->numElements); 793 } 794 795 return primCount; 796 } 797 798 static void writeBufferGuard (const glw::Functions& gl, deUint32 target, int bufferSize, int guardSize) 799 { 800 deUint8* ptr = (deUint8*)gl.mapBufferRange(target, bufferSize, guardSize, GL_MAP_WRITE_BIT); 801 if (ptr) 802 deMemset(ptr, 0xcd, guardSize); 803 gl.unmapBuffer(target); 804 GLU_EXPECT_NO_ERROR(gl.getError(), "guardband write"); 805 } 806 807 static bool verifyGuard (const deUint8* ptr, int guardSize) 808 { 809 for (int ndx = 0; ndx < guardSize; ndx++) 810 { 811 if (ptr[ndx] != 0xcd) 812 return false; 813 } 814 return true; 815 } 816 817 static void logTransformFeedbackVaryings (TestLog& log, const glw::Functions& gl, deUint32 program) 818 { 819 int numTfVaryings = 0; 820 int maxNameLen = 0; 821 822 gl.getProgramiv(program, GL_TRANSFORM_FEEDBACK_VARYINGS, &numTfVaryings); 823 gl.getProgramiv(program, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, &maxNameLen); 824 GLU_EXPECT_NO_ERROR(gl.getError(), "Query TF varyings"); 825 826 log << TestLog::Message << "GL_TRANSFORM_FEEDBACK_VARYINGS = " << numTfVaryings << TestLog::EndMessage; 827 828 vector<char> nameBuf(maxNameLen+1); 829 830 for (int ndx = 0; ndx < numTfVaryings; ndx++) 831 { 832 glw::GLsizei size = 0; 833 glw::GLenum type = 0; 834 835 gl.getTransformFeedbackVarying(program, ndx, (glw::GLsizei)nameBuf.size(), DE_NULL, &size, &type, &nameBuf[0]); 836 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTransformFeedbackVarying()"); 837 838 const glu::DataType dataType = glu::getDataTypeFromGLType(type); 839 const std::string typeName = dataType != glu::TYPE_LAST ? std::string(glu::getDataTypeName(dataType)) 840 : (std::string("unknown(") + tcu::toHex(type).toString() + ")"); 841 842 log << TestLog::Message << (const char*)&nameBuf[0] << ": " << typeName << "[" << size << "]" << TestLog::EndMessage; 843 } 844 } 845 846 class TransformFeedbackCase : public TestCase 847 { 848 public: 849 TransformFeedbackCase (Context& context, const char* name, const char* desc, deUint32 bufferMode, deUint32 primitiveType); 850 ~TransformFeedbackCase (void); 851 852 void init (void); 853 void deinit (void); 854 IterateResult iterate (void); 855 856 protected: 857 ProgramSpec m_progSpec; 858 deUint32 m_bufferMode; 859 deUint32 m_primitiveType; 860 861 private: 862 TransformFeedbackCase (const TransformFeedbackCase& other); 863 TransformFeedbackCase& operator= (const TransformFeedbackCase& other); 864 865 bool runTest (const DrawCall* first, const DrawCall* end, deUint32 seed); 866 867 // Derived from ProgramSpec in init() 868 int m_inputStride; 869 vector<Attribute> m_attributes; 870 vector<Output> m_transformFeedbackOutputs; 871 vector<int> m_bufferStrides; 872 873 // GL state. 874 glu::ShaderProgram* m_program; 875 glu::TransformFeedback* m_transformFeedback; 876 vector<deUint32> m_outputBuffers; 877 878 int m_iterNdx; 879 }; 880 881 TransformFeedbackCase::TransformFeedbackCase (Context& context, const char* name, const char* desc, deUint32 bufferMode, deUint32 primitiveType) 882 : TestCase (context, name, desc) 883 , m_bufferMode (bufferMode) 884 , m_primitiveType (primitiveType) 885 , m_inputStride (0) 886 , m_program (DE_NULL) 887 , m_transformFeedback (DE_NULL) 888 , m_iterNdx (0) 889 { 890 } 891 892 TransformFeedbackCase::~TransformFeedbackCase (void) 893 { 894 TransformFeedbackCase::deinit(); 895 } 896 897 static bool hasArraysInTFVaryings (const ProgramSpec& spec) 898 { 899 for (vector<string>::const_iterator tfVar = spec.getTransformFeedbackVaryings().begin(); tfVar != spec.getTransformFeedbackVaryings().end(); ++tfVar) 900 { 901 string varName = glu::parseVariableName(tfVar->c_str()); 902 vector<Varying>::const_iterator varIter = std::find_if(spec.getVaryings().begin(), spec.getVaryings().end(), VaryingNameEquals(varName)); 903 904 if (varName == "gl_Position" || varName == "gl_PointSize") 905 continue; 906 907 DE_ASSERT(varIter != spec.getVaryings().end()); 908 909 if (varIter->type.isArrayType()) 910 return true; 911 } 912 913 return false; 914 } 915 916 void TransformFeedbackCase::init (void) 917 { 918 TestLog& log = m_testCtx.getLog(); 919 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 920 921 DE_ASSERT(!m_program); 922 m_program = createVertexCaptureProgram(m_context.getRenderContext(), m_progSpec, m_bufferMode, m_primitiveType); 923 924 log << *m_program; 925 if (!m_program->isOk()) 926 { 927 const bool linkFail = m_program->getShaderInfo(glu::SHADERTYPE_VERTEX).compileOk && 928 m_program->getShaderInfo(glu::SHADERTYPE_FRAGMENT).compileOk && 929 !m_program->getProgramInfo().linkOk; 930 931 if (linkFail) 932 { 933 if (!isProgramSupported(gl, m_progSpec, m_bufferMode)) 934 throw tcu::NotSupportedError("Implementation limits execeeded", "", __FILE__, __LINE__); 935 else if (hasArraysInTFVaryings(m_progSpec)) 936 throw tcu::NotSupportedError("Capturing arrays is not supported (undefined in specification)", "", __FILE__, __LINE__); 937 else 938 throw tcu::TestError("Link failed", "", __FILE__, __LINE__); 939 } 940 else 941 throw tcu::TestError("Compile failed", "", __FILE__, __LINE__); 942 } 943 944 log << TestLog::Message << "Transform feedback varyings: " << tcu::formatArray(m_progSpec.getTransformFeedbackVaryings().begin(), m_progSpec.getTransformFeedbackVaryings().end()) << TestLog::EndMessage; 945 946 // Print out transform feedback points reported by GL. 947 log << TestLog::Message << "Transform feedback varyings reported by compiler:" << TestLog::EndMessage; 948 logTransformFeedbackVaryings(log, gl, m_program->getProgram()); 949 950 // Compute input specification. 951 computeInputLayout(m_attributes, m_inputStride, m_progSpec.getVaryings(), m_progSpec.isPointSizeUsed()); 952 953 // Build list of varyings used in transform feedback. 954 computeTransformFeedbackOutputs(m_transformFeedbackOutputs, m_attributes, m_progSpec.getVaryings(), m_progSpec.getTransformFeedbackVaryings(), m_bufferMode); 955 DE_ASSERT(!m_transformFeedbackOutputs.empty()); 956 957 // Buffer strides. 958 DE_ASSERT(m_bufferStrides.empty()); 959 if (m_bufferMode == GL_SEPARATE_ATTRIBS) 960 { 961 for (vector<Output>::const_iterator outIter = m_transformFeedbackOutputs.begin(); outIter != m_transformFeedbackOutputs.end(); outIter++) 962 m_bufferStrides.push_back(outIter->type.getScalarSize()*sizeof(deUint32)); 963 } 964 else 965 { 966 int totalSize = 0; 967 for (vector<Output>::const_iterator outIter = m_transformFeedbackOutputs.begin(); outIter != m_transformFeedbackOutputs.end(); outIter++) 968 totalSize += outIter->type.getScalarSize()*sizeof(deUint32); 969 970 m_bufferStrides.push_back(totalSize); 971 } 972 973 // \note Actual storage is allocated in iterate(). 974 m_outputBuffers.resize(m_bufferStrides.size()); 975 gl.genBuffers((glw::GLsizei)m_outputBuffers.size(), &m_outputBuffers[0]); 976 977 DE_ASSERT(!m_transformFeedback); 978 m_transformFeedback = new glu::TransformFeedback(m_context.getRenderContext()); 979 980 GLU_EXPECT_NO_ERROR(gl.getError(), "init"); 981 982 m_iterNdx = 0; 983 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 984 } 985 986 void TransformFeedbackCase::deinit (void) 987 { 988 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 989 990 if (!m_outputBuffers.empty()) 991 { 992 gl.deleteBuffers((glw::GLsizei)m_outputBuffers.size(), &m_outputBuffers[0]); 993 m_outputBuffers.clear(); 994 } 995 996 delete m_transformFeedback; 997 m_transformFeedback = DE_NULL; 998 999 delete m_program; 1000 m_program = DE_NULL; 1001 1002 // Clean up state. 1003 m_attributes.clear(); 1004 m_transformFeedbackOutputs.clear(); 1005 m_bufferStrides.clear(); 1006 m_inputStride = 0; 1007 } 1008 1009 TransformFeedbackCase::IterateResult TransformFeedbackCase::iterate (void) 1010 { 1011 // Test cases. 1012 static const DrawCall s_elemCount1[] = { DrawCall(1, true) }; 1013 static const DrawCall s_elemCount2[] = { DrawCall(2, true) }; 1014 static const DrawCall s_elemCount3[] = { DrawCall(3, true) }; 1015 static const DrawCall s_elemCount4[] = { DrawCall(4, true) }; 1016 static const DrawCall s_elemCount123[] = { DrawCall(123, true) }; 1017 static const DrawCall s_basicPause1[] = { DrawCall(64, true), DrawCall(64, false), DrawCall(64, true) }; 1018 static const DrawCall s_basicPause2[] = { DrawCall(13, true), DrawCall(5, true), DrawCall(17, false), DrawCall(3, true), DrawCall(7, false) }; 1019 static const DrawCall s_startPaused[] = { DrawCall(123, false), DrawCall(123, true) }; 1020 static const DrawCall s_random1[] = { DrawCall(65, true), DrawCall(135, false), DrawCall(74, true), DrawCall(16, false), DrawCall(226, false), DrawCall(9, true), DrawCall(174, false) }; 1021 static const DrawCall s_random2[] = { DrawCall(217, true), DrawCall(171, true), DrawCall(147, true), DrawCall(152, false), DrawCall(55, true) }; 1022 1023 static const struct 1024 { 1025 const DrawCall* calls; 1026 int numCalls; 1027 } s_iterations[] = 1028 { 1029 #define ITER(ARR) { ARR, DE_LENGTH_OF_ARRAY(ARR) } 1030 ITER(s_elemCount1), 1031 ITER(s_elemCount2), 1032 ITER(s_elemCount3), 1033 ITER(s_elemCount4), 1034 ITER(s_elemCount123), 1035 ITER(s_basicPause1), 1036 ITER(s_basicPause2), 1037 ITER(s_startPaused), 1038 ITER(s_random1), 1039 ITER(s_random2) 1040 #undef ITER 1041 }; 1042 1043 TestLog& log = m_testCtx.getLog(); 1044 bool isOk = true; 1045 deUint32 seed = deStringHash(getName()) ^ deInt32Hash(m_iterNdx); 1046 int numIterations = DE_LENGTH_OF_ARRAY(s_iterations); 1047 const DrawCall* first = s_iterations[m_iterNdx].calls; 1048 const DrawCall* end = s_iterations[m_iterNdx].calls + s_iterations[m_iterNdx].numCalls; 1049 1050 std::string sectionName = std::string("Iteration") + de::toString(m_iterNdx+1); 1051 std::string sectionDesc = std::string("Iteration ") + de::toString(m_iterNdx+1) + " / " + de::toString(numIterations); 1052 tcu::ScopedLogSection section (log, sectionName, sectionDesc); 1053 1054 log << TestLog::Message << "Testing " << s_iterations[m_iterNdx].numCalls << " draw calls, (element count, TF state): " << tcu::formatArray(first, end) << TestLog::EndMessage; 1055 1056 isOk = runTest(first, end, seed); 1057 1058 if (!isOk) 1059 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Result comparison failed"); 1060 1061 m_iterNdx += 1; 1062 return (isOk && m_iterNdx < numIterations) ? CONTINUE : STOP; 1063 } 1064 1065 bool TransformFeedbackCase::runTest (const DrawCall* first, const DrawCall* end, deUint32 seed) 1066 { 1067 TestLog& log = m_testCtx.getLog(); 1068 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1069 de::Random rnd (seed); 1070 int numInputs = 0; //!< Sum of element counts in calls. 1071 int numOutputs = 0; //!< Sum of output counts for calls that have transform feedback enabled. 1072 int width = m_context.getRenderContext().getRenderTarget().getWidth(); 1073 int height = m_context.getRenderContext().getRenderTarget().getHeight(); 1074 int viewportW = de::min((int)VIEWPORT_WIDTH, width); 1075 int viewportH = de::min((int)VIEWPORT_HEIGHT, height); 1076 int viewportX = rnd.getInt(0, width-viewportW); 1077 int viewportY = rnd.getInt(0, height-viewportH); 1078 tcu::Surface frameWithTf (viewportW, viewportH); 1079 tcu::Surface frameWithoutTf (viewportW, viewportH); 1080 glu::Query primitiveQuery (m_context.getRenderContext()); 1081 bool outputsOk = true; 1082 bool imagesOk = true; 1083 bool queryOk = true; 1084 1085 // Compute totals. 1086 for (const DrawCall* call = first; call != end; call++) 1087 { 1088 numInputs += call->numElements; 1089 numOutputs += call->transformFeedbackEnabled ? getTransformFeedbackOutputCount(m_primitiveType, call->numElements) : 0; 1090 } 1091 1092 // Input data. 1093 vector<deUint8> inputData(m_inputStride*numInputs); 1094 genInputData(m_attributes, numInputs, m_inputStride, &inputData[0], rnd); 1095 1096 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback->get()); 1097 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedback()"); 1098 1099 // Allocate storage for transform feedback output buffers and bind to targets. 1100 for (int bufNdx = 0; bufNdx < (int)m_outputBuffers.size(); bufNdx++) 1101 { 1102 deUint32 buffer = m_outputBuffers[bufNdx]; 1103 int stride = m_bufferStrides[bufNdx]; 1104 int target = bufNdx; 1105 int size = stride*numOutputs; 1106 int guardSize = stride*BUFFER_GUARD_MULTIPLIER; 1107 const deUint32 usage = GL_DYNAMIC_READ; 1108 1109 gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buffer); 1110 gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, size+guardSize, DE_NULL, usage); 1111 writeBufferGuard(gl, GL_TRANSFORM_FEEDBACK_BUFFER, size, guardSize); 1112 1113 // \todo [2012-07-30 pyry] glBindBufferRange()? 1114 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, target, buffer); 1115 1116 GLU_EXPECT_NO_ERROR(gl.getError(), "transform feedback buffer setup"); 1117 } 1118 1119 // Setup attributes. 1120 for (vector<Attribute>::const_iterator attrib = m_attributes.begin(); attrib != m_attributes.end(); attrib++) 1121 { 1122 int loc = gl.getAttribLocation(m_program->getProgram(), attrib->name.c_str()); 1123 glu::DataType scalarType = glu::getDataTypeScalarType(attrib->type.getBasicType()); 1124 int numComponents = glu::getDataTypeScalarSize(attrib->type.getBasicType()); 1125 const void* ptr = &inputData[0] + attrib->offset; 1126 1127 if (loc >= 0) 1128 { 1129 gl.enableVertexAttribArray(loc); 1130 1131 if (scalarType == glu::TYPE_FLOAT) gl.vertexAttribPointer (loc, numComponents, GL_FLOAT, GL_FALSE, m_inputStride, ptr); 1132 else if (scalarType == glu::TYPE_INT) gl.vertexAttribIPointer (loc, numComponents, GL_INT, m_inputStride, ptr); 1133 else if (scalarType == glu::TYPE_UINT) gl.vertexAttribIPointer (loc, numComponents, GL_UNSIGNED_INT, m_inputStride, ptr); 1134 } 1135 } 1136 1137 // Setup viewport. 1138 gl.viewport(viewportX, viewportY, viewportW, viewportH); 1139 1140 // Setup program. 1141 gl.useProgram(m_program->getProgram()); 1142 1143 gl.uniform4fv(gl.getUniformLocation(m_program->getProgram(), "u_scale"), 1, tcu::Vec4(0.01f).getPtr()); 1144 gl.uniform4fv(gl.getUniformLocation(m_program->getProgram(), "u_bias"), 1, tcu::Vec4(0.5f).getPtr()); 1145 1146 // Enable query. 1147 gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, *primitiveQuery); 1148 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN)"); 1149 1150 // Draw. 1151 { 1152 int offset = 0; 1153 bool tfEnabled = true; 1154 1155 gl.clear(GL_COLOR_BUFFER_BIT); 1156 1157 gl.beginTransformFeedback(getTransformFeedbackPrimitiveMode(m_primitiveType)); 1158 1159 for (const DrawCall* call = first; call != end; call++) 1160 { 1161 // Pause or resume transform feedback if necessary. 1162 if (call->transformFeedbackEnabled != tfEnabled) 1163 { 1164 if (call->transformFeedbackEnabled) 1165 gl.resumeTransformFeedback(); 1166 else 1167 gl.pauseTransformFeedback(); 1168 tfEnabled = call->transformFeedbackEnabled; 1169 } 1170 1171 gl.drawArrays(m_primitiveType, offset, call->numElements); 1172 offset += call->numElements; 1173 } 1174 1175 // Resume feedback before finishing it. 1176 if (!tfEnabled) 1177 gl.resumeTransformFeedback(); 1178 1179 gl.endTransformFeedback(); 1180 GLU_EXPECT_NO_ERROR(gl.getError(), "render"); 1181 } 1182 1183 gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); 1184 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN)"); 1185 1186 // Check and log query status right after submit 1187 { 1188 deUint32 available = GL_FALSE; 1189 gl.getQueryObjectuiv(*primitiveQuery, GL_QUERY_RESULT_AVAILABLE, &available); 1190 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryObjectuiv()"); 1191 1192 log << TestLog::Message << "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN status after submit: " << (available != GL_FALSE ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage; 1193 } 1194 1195 // Compare result buffers. 1196 for (int bufferNdx = 0; bufferNdx < (int)m_outputBuffers.size(); bufferNdx++) 1197 { 1198 deUint32 buffer = m_outputBuffers[bufferNdx]; 1199 int stride = m_bufferStrides[bufferNdx]; 1200 int size = stride*numOutputs; 1201 int guardSize = stride*BUFFER_GUARD_MULTIPLIER; 1202 const void* bufPtr = DE_NULL; 1203 1204 // Bind buffer for reading. 1205 gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buffer); 1206 bufPtr = gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, size+guardSize, GL_MAP_READ_BIT); 1207 GLU_EXPECT_NO_ERROR(gl.getError(), "mapping buffer"); 1208 1209 // Verify all output variables that are written to this buffer. 1210 for (vector<Output>::const_iterator out = m_transformFeedbackOutputs.begin(); out != m_transformFeedbackOutputs.end(); out++) 1211 { 1212 if (out->bufferNdx != bufferNdx) 1213 continue; 1214 1215 int inputOffset = 0; 1216 int outputOffset = 0; 1217 1218 // Process all draw calls and check ones with transform feedback enabled. 1219 for (const DrawCall* call = first; call != end; call++) 1220 { 1221 if (call->transformFeedbackEnabled) 1222 { 1223 const deUint8* inputPtr = &inputData[0] + inputOffset*m_inputStride; 1224 const deUint8* outputPtr = (const deUint8*)bufPtr + outputOffset*stride; 1225 1226 if (!compareTransformFeedbackOutput(log, m_primitiveType, *out, call->numElements, inputPtr, m_inputStride, outputPtr, stride)) 1227 { 1228 outputsOk = false; 1229 break; 1230 } 1231 } 1232 1233 inputOffset += call->numElements; 1234 outputOffset += call->transformFeedbackEnabled ? getTransformFeedbackOutputCount(m_primitiveType, call->numElements) : 0; 1235 } 1236 } 1237 1238 // Verify guardband. 1239 if (!verifyGuard((const deUint8*)bufPtr + size, guardSize)) 1240 { 1241 log << TestLog::Message << "Error: Transform feedback buffer overrun detected" << TestLog::EndMessage; 1242 outputsOk = false; 1243 } 1244 1245 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 1246 } 1247 1248 // Check status after mapping buffers. 1249 { 1250 const bool mustBeReady = !m_outputBuffers.empty(); // Mapping buffer forces synchronization. 1251 const int expectedCount = computeTransformFeedbackPrimitiveCount(m_primitiveType, first, end); 1252 deUint32 available = GL_FALSE; 1253 deUint32 numPrimitives = 0; 1254 1255 gl.getQueryObjectuiv(*primitiveQuery, GL_QUERY_RESULT_AVAILABLE, &available); 1256 gl.getQueryObjectuiv(*primitiveQuery, GL_QUERY_RESULT, &numPrimitives); 1257 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryObjectuiv()"); 1258 1259 if (!mustBeReady && available == GL_FALSE) 1260 { 1261 log << TestLog::Message << "ERROR: GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN result not available after mapping buffers!" << TestLog::EndMessage; 1262 queryOk = false; 1263 } 1264 1265 log << TestLog::Message << "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = " << numPrimitives << TestLog::EndMessage; 1266 1267 if ((int)numPrimitives != expectedCount) 1268 { 1269 log << TestLog::Message << "ERROR: Expected " << expectedCount << " primitives!" << TestLog::EndMessage; 1270 queryOk = false; 1271 } 1272 } 1273 1274 // Clear transform feedback state. 1275 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); 1276 for (int bufNdx = 0; bufNdx < (int)m_outputBuffers.size(); bufNdx++) 1277 { 1278 gl.bindBuffer (GL_TRANSFORM_FEEDBACK_BUFFER, 0); 1279 gl.bindBufferBase (GL_TRANSFORM_FEEDBACK_BUFFER, bufNdx, 0); 1280 } 1281 1282 // Read back rendered image. 1283 glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, frameWithTf.getAccess()); 1284 1285 // Render without transform feedback. 1286 { 1287 int offset = 0; 1288 1289 gl.clear(GL_COLOR_BUFFER_BIT); 1290 1291 for (const DrawCall* call = first; call != end; call++) 1292 { 1293 gl.drawArrays(m_primitiveType, offset, call->numElements); 1294 offset += call->numElements; 1295 } 1296 1297 GLU_EXPECT_NO_ERROR(gl.getError(), "render"); 1298 glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, frameWithoutTf.getAccess()); 1299 } 1300 1301 // Compare images with and without transform feedback. 1302 imagesOk = tcu::pixelThresholdCompare(log, "Result", "Image comparison result", frameWithoutTf, frameWithTf, tcu::RGBA(1, 1, 1, 1), tcu::COMPARE_LOG_ON_ERROR); 1303 1304 if (imagesOk) 1305 m_testCtx.getLog() << TestLog::Message << "Rendering result comparison between TF enabled and TF disabled passed." << TestLog::EndMessage; 1306 else 1307 m_testCtx.getLog() << TestLog::Message << "ERROR: Rendering result comparison between TF enabled and TF disabled failed!" << TestLog::EndMessage; 1308 1309 return outputsOk && imagesOk && queryOk; 1310 } 1311 1312 // Test cases. 1313 1314 class PositionCase : public TransformFeedbackCase 1315 { 1316 public: 1317 PositionCase (Context& context, const char* name, const char* desc, deUint32 bufferType, deUint32 primitiveType) 1318 : TransformFeedbackCase(context, name, desc, bufferType, primitiveType) 1319 { 1320 m_progSpec.addTransformFeedbackVarying("gl_Position"); 1321 } 1322 }; 1323 1324 class PointSizeCase : public TransformFeedbackCase 1325 { 1326 public: 1327 PointSizeCase (Context& context, const char* name, const char* desc, deUint32 bufferType, deUint32 primitiveType) 1328 : TransformFeedbackCase(context, name, desc, bufferType, primitiveType) 1329 { 1330 m_progSpec.addTransformFeedbackVarying("gl_PointSize"); 1331 } 1332 }; 1333 1334 class BasicTypeCase : public TransformFeedbackCase 1335 { 1336 public: 1337 BasicTypeCase (Context& context, const char* name, const char* desc, deUint32 bufferType, deUint32 primitiveType, glu::DataType type, glu::Precision precision, Interpolation interpolation) 1338 : TransformFeedbackCase(context, name, desc, bufferType, primitiveType) 1339 { 1340 m_progSpec.addVarying("v_varA", glu::VarType(type, precision), interpolation); 1341 m_progSpec.addVarying("v_varB", glu::VarType(type, precision), interpolation); 1342 1343 m_progSpec.addTransformFeedbackVarying("v_varA"); 1344 m_progSpec.addTransformFeedbackVarying("v_varB"); 1345 } 1346 }; 1347 1348 class BasicArrayCase : public TransformFeedbackCase 1349 { 1350 public: 1351 BasicArrayCase (Context& context, const char* name, const char* desc, deUint32 bufferType, deUint32 primitiveType, glu::DataType type, glu::Precision precision, Interpolation interpolation) 1352 : TransformFeedbackCase(context, name, desc, bufferType, primitiveType) 1353 { 1354 if (glu::isDataTypeMatrix(type) || m_bufferMode == GL_SEPARATE_ATTRIBS) 1355 { 1356 // \note For matrix types we need to use reduced array sizes or otherwise we will exceed maximum attribute (16) 1357 // or transform feedback component count (64). 1358 // On separate attribs mode maximum component count per varying is 4. 1359 m_progSpec.addVarying("v_varA", glu::VarType(glu::VarType(type, precision), 1), interpolation); 1360 m_progSpec.addVarying("v_varB", glu::VarType(glu::VarType(type, precision), 2), interpolation); 1361 } 1362 else 1363 { 1364 m_progSpec.addVarying("v_varA", glu::VarType(glu::VarType(type, precision), 3), interpolation); 1365 m_progSpec.addVarying("v_varB", glu::VarType(glu::VarType(type, precision), 4), interpolation); 1366 } 1367 1368 m_progSpec.addTransformFeedbackVarying("v_varA"); 1369 m_progSpec.addTransformFeedbackVarying("v_varB"); 1370 } 1371 }; 1372 1373 class ArrayElementCase : public TransformFeedbackCase 1374 { 1375 public: 1376 ArrayElementCase (Context& context, const char* name, const char* desc, deUint32 bufferType, deUint32 primitiveType, glu::DataType type, glu::Precision precision, Interpolation interpolation) 1377 : TransformFeedbackCase(context, name, desc, bufferType, primitiveType) 1378 { 1379 m_progSpec.addVarying("v_varA", glu::VarType(glu::VarType(type, precision), 3), interpolation); 1380 m_progSpec.addVarying("v_varB", glu::VarType(glu::VarType(type, precision), 4), interpolation); 1381 1382 m_progSpec.addTransformFeedbackVarying("v_varA[1]"); 1383 m_progSpec.addTransformFeedbackVarying("v_varB[0]"); 1384 m_progSpec.addTransformFeedbackVarying("v_varB[3]"); 1385 } 1386 }; 1387 1388 class RandomCase : public TransformFeedbackCase 1389 { 1390 public: 1391 RandomCase (Context& context, const char* name, const char* desc, deUint32 bufferType, deUint32 primitiveType, deUint32 seed) 1392 : TransformFeedbackCase (context, name, desc, bufferType, primitiveType) 1393 , m_seed (seed) 1394 { 1395 } 1396 1397 void init (void) 1398 { 1399 // \note Hard-coded indices and hackery are used when indexing this, beware. 1400 static const glu::DataType typeCandidates[] = 1401 { 1402 glu::TYPE_FLOAT, 1403 glu::TYPE_FLOAT_VEC2, 1404 glu::TYPE_FLOAT_VEC3, 1405 glu::TYPE_FLOAT_VEC4, 1406 glu::TYPE_INT, 1407 glu::TYPE_INT_VEC2, 1408 glu::TYPE_INT_VEC3, 1409 glu::TYPE_INT_VEC4, 1410 glu::TYPE_UINT, 1411 glu::TYPE_UINT_VEC2, 1412 glu::TYPE_UINT_VEC3, 1413 glu::TYPE_UINT_VEC4, 1414 1415 glu::TYPE_FLOAT_MAT2, 1416 glu::TYPE_FLOAT_MAT2X3, 1417 glu::TYPE_FLOAT_MAT2X4, 1418 1419 glu::TYPE_FLOAT_MAT3X2, 1420 glu::TYPE_FLOAT_MAT3, 1421 glu::TYPE_FLOAT_MAT3X4, 1422 1423 glu::TYPE_FLOAT_MAT4X2, 1424 glu::TYPE_FLOAT_MAT4X3, 1425 glu::TYPE_FLOAT_MAT4 1426 }; 1427 1428 static const glu::Precision precisions[] = 1429 { 1430 glu::PRECISION_LOWP, 1431 glu::PRECISION_MEDIUMP, 1432 glu::PRECISION_HIGHP 1433 }; 1434 1435 static const Interpolation interpModes[] = 1436 { 1437 INTERPOLATION_FLAT, 1438 INTERPOLATION_SMOOTH, 1439 INTERPOLATION_CENTROID 1440 }; 1441 1442 const int maxAttributeVectors = 16; 1443 // const int maxTransformFeedbackComponents = 64; // \note It is enough to limit attribute set size. 1444 bool isSeparateMode = m_bufferMode == GL_SEPARATE_ATTRIBS; 1445 int maxTransformFeedbackVars = isSeparateMode ? 4 : maxAttributeVectors; 1446 const float arrayWeight = 0.3f; 1447 const float positionWeight = 0.7f; 1448 const float pointSizeWeight = 0.1f; 1449 const float captureFullArrayWeight = 0.5f; 1450 1451 de::Random rnd (m_seed); 1452 bool usePosition = rnd.getFloat() < positionWeight; 1453 bool usePointSize = rnd.getFloat() < pointSizeWeight; 1454 int numAttribVectorsToUse = rnd.getInt(1, maxAttributeVectors - 1/*position*/ - (usePointSize ? 1 : 0)); 1455 1456 int numAttributeVectors = 0; 1457 int varNdx = 0; 1458 1459 // Generate varyings. 1460 while (numAttributeVectors < numAttribVectorsToUse) 1461 { 1462 int maxVecs = isSeparateMode ? de::min(2 /*at most 2*mat2*/, numAttribVectorsToUse-numAttributeVectors) : numAttribVectorsToUse-numAttributeVectors; 1463 const glu::DataType* begin = &typeCandidates[0]; 1464 const glu::DataType* end = begin + (maxVecs >= 4 ? 21 : 1465 maxVecs >= 3 ? 18 : 1466 maxVecs >= 2 ? (isSeparateMode ? 13 : 15) : 12); 1467 1468 glu::DataType type = rnd.choose<glu::DataType>(begin, end); 1469 glu::Precision precision = rnd.choose<glu::Precision>(&precisions[0], &precisions[0]+DE_LENGTH_OF_ARRAY(precisions)); 1470 Interpolation interp = glu::getDataTypeScalarType(type) == glu::TYPE_FLOAT 1471 ? rnd.choose<Interpolation>(&interpModes[0], &interpModes[0]+DE_LENGTH_OF_ARRAY(interpModes)) 1472 : INTERPOLATION_FLAT; 1473 int numVecs = glu::isDataTypeMatrix(type) ? glu::getDataTypeMatrixNumColumns(type) : 1; 1474 int numComps = glu::getDataTypeScalarSize(type); 1475 int maxArrayLen = de::max(1, isSeparateMode ? 4/numComps : maxVecs/numVecs); 1476 bool useArray = rnd.getFloat() < arrayWeight; 1477 int arrayLen = useArray ? rnd.getInt(1, maxArrayLen) : 1; 1478 std::string name = "v_var" + de::toString(varNdx); 1479 1480 if (useArray) 1481 m_progSpec.addVarying(name.c_str(), glu::VarType(glu::VarType(type, precision), arrayLen), interp); 1482 else 1483 m_progSpec.addVarying(name.c_str(), glu::VarType(type, precision), interp); 1484 1485 numAttributeVectors += arrayLen*numVecs; 1486 varNdx += 1; 1487 } 1488 1489 // Generate transform feedback candidate set. 1490 vector<string> tfCandidates; 1491 1492 if (usePosition) tfCandidates.push_back("gl_Position"); 1493 if (usePointSize) tfCandidates.push_back("gl_PointSize"); 1494 1495 for (int ndx = 0; ndx < varNdx /* num varyings */; ndx++) 1496 { 1497 const Varying& var = m_progSpec.getVaryings()[ndx]; 1498 1499 if (var.type.isArrayType()) 1500 { 1501 const bool captureFull = rnd.getFloat() < captureFullArrayWeight; 1502 1503 if (captureFull) 1504 tfCandidates.push_back(var.name); 1505 else 1506 { 1507 const int numElem = var.type.getArraySize(); 1508 for (int elemNdx = 0; elemNdx < numElem; elemNdx++) 1509 tfCandidates.push_back(var.name + "[" + de::toString(elemNdx) + "]"); 1510 } 1511 } 1512 else 1513 tfCandidates.push_back(var.name); 1514 } 1515 1516 // Pick random selection. 1517 vector<string> tfVaryings(de::min((int)tfCandidates.size(), maxTransformFeedbackVars)); 1518 rnd.choose(tfCandidates.begin(), tfCandidates.end(), tfVaryings.begin(), (int)tfVaryings.size()); 1519 rnd.shuffle(tfVaryings.begin(), tfVaryings.end()); 1520 1521 for (vector<string>::const_iterator var = tfVaryings.begin(); var != tfVaryings.end(); var++) 1522 m_progSpec.addTransformFeedbackVarying(var->c_str()); 1523 1524 TransformFeedbackCase::init(); 1525 } 1526 1527 private: 1528 deUint32 m_seed; 1529 }; 1530 1531 } // TransformFeedback 1532 1533 using namespace TransformFeedback; 1534 1535 TransformFeedbackTests::TransformFeedbackTests (Context& context) 1536 : TestCaseGroup(context, "transform_feedback", "Transform feedback tests") 1537 { 1538 } 1539 1540 TransformFeedbackTests::~TransformFeedbackTests (void) 1541 { 1542 } 1543 1544 void TransformFeedbackTests::init (void) 1545 { 1546 static const struct 1547 { 1548 const char* name; 1549 deUint32 mode; 1550 } bufferModes[] = 1551 { 1552 { "separate", GL_SEPARATE_ATTRIBS }, 1553 { "interleaved", GL_INTERLEAVED_ATTRIBS } 1554 }; 1555 1556 static const struct 1557 { 1558 const char* name; 1559 deUint32 type; 1560 } primitiveTypes[] = 1561 { 1562 { "points", GL_POINTS }, 1563 { "lines", GL_LINES }, 1564 { "triangles", GL_TRIANGLES } 1565 1566 // Not supported by GLES3. 1567 // { "line_strip", GL_LINE_STRIP }, 1568 // { "line_loop", GL_LINE_LOOP }, 1569 // { "triangle_fan", GL_TRIANGLE_FAN }, 1570 // { "triangle_strip", GL_TRIANGLE_STRIP } 1571 }; 1572 1573 static const glu::DataType basicTypes[] = 1574 { 1575 glu::TYPE_FLOAT, 1576 glu::TYPE_FLOAT_VEC2, 1577 glu::TYPE_FLOAT_VEC3, 1578 glu::TYPE_FLOAT_VEC4, 1579 glu::TYPE_FLOAT_MAT2, 1580 glu::TYPE_FLOAT_MAT2X3, 1581 glu::TYPE_FLOAT_MAT2X4, 1582 glu::TYPE_FLOAT_MAT3X2, 1583 glu::TYPE_FLOAT_MAT3, 1584 glu::TYPE_FLOAT_MAT3X4, 1585 glu::TYPE_FLOAT_MAT4X2, 1586 glu::TYPE_FLOAT_MAT4X3, 1587 glu::TYPE_FLOAT_MAT4, 1588 glu::TYPE_INT, 1589 glu::TYPE_INT_VEC2, 1590 glu::TYPE_INT_VEC3, 1591 glu::TYPE_INT_VEC4, 1592 glu::TYPE_UINT, 1593 glu::TYPE_UINT_VEC2, 1594 glu::TYPE_UINT_VEC3, 1595 glu::TYPE_UINT_VEC4 1596 }; 1597 1598 static const glu::Precision precisions[] = 1599 { 1600 glu::PRECISION_LOWP, 1601 glu::PRECISION_MEDIUMP, 1602 glu::PRECISION_HIGHP 1603 }; 1604 1605 static const struct 1606 { 1607 const char* name; 1608 Interpolation interp; 1609 } interpModes[] = 1610 { 1611 { "smooth", INTERPOLATION_SMOOTH }, 1612 { "flat", INTERPOLATION_FLAT }, 1613 { "centroid", INTERPOLATION_CENTROID } 1614 }; 1615 1616 // .position 1617 { 1618 tcu::TestCaseGroup* positionGroup = new tcu::TestCaseGroup(m_testCtx, "position", "gl_Position capture using transform feedback"); 1619 addChild(positionGroup); 1620 1621 for (int primitiveType = 0; primitiveType < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveType++) 1622 { 1623 for (int bufferMode = 0; bufferMode < DE_LENGTH_OF_ARRAY(bufferModes); bufferMode++) 1624 { 1625 string name = string(primitiveTypes[primitiveType].name) + "_" + bufferModes[bufferMode].name; 1626 positionGroup->addChild(new PositionCase(m_context, name.c_str(), "", bufferModes[bufferMode].mode, primitiveTypes[primitiveType].type)); 1627 } 1628 } 1629 } 1630 1631 // .point_size 1632 { 1633 tcu::TestCaseGroup* pointSizeGroup = new tcu::TestCaseGroup(m_testCtx, "point_size", "gl_PointSize capture using transform feedback"); 1634 addChild(pointSizeGroup); 1635 1636 for (int primitiveType = 0; primitiveType < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveType++) 1637 { 1638 for (int bufferMode = 0; bufferMode < DE_LENGTH_OF_ARRAY(bufferModes); bufferMode++) 1639 { 1640 string name = string(primitiveTypes[primitiveType].name) + "_" + bufferModes[bufferMode].name; 1641 pointSizeGroup->addChild(new PointSizeCase(m_context, name.c_str(), "", bufferModes[bufferMode].mode, primitiveTypes[primitiveType].type)); 1642 } 1643 } 1644 } 1645 1646 // .basic_type 1647 { 1648 tcu::TestCaseGroup* basicTypeGroup = new tcu::TestCaseGroup(m_testCtx, "basic_types", "Basic types in transform feedback"); 1649 addChild(basicTypeGroup); 1650 1651 for (int bufferModeNdx = 0; bufferModeNdx < DE_LENGTH_OF_ARRAY(bufferModes); bufferModeNdx++) 1652 { 1653 tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[bufferModeNdx].name, ""); 1654 deUint32 bufferMode = bufferModes[bufferModeNdx].mode; 1655 basicTypeGroup->addChild(modeGroup); 1656 1657 for (int primitiveTypeNdx = 0; primitiveTypeNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveTypeNdx++) 1658 { 1659 tcu::TestCaseGroup* primitiveGroup = new tcu::TestCaseGroup(m_testCtx, primitiveTypes[primitiveTypeNdx].name, ""); 1660 deUint32 primitiveType = primitiveTypes[primitiveTypeNdx].type; 1661 modeGroup->addChild(primitiveGroup); 1662 1663 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(basicTypes); typeNdx++) 1664 { 1665 glu::DataType type = basicTypes[typeNdx]; 1666 bool isFloat = glu::getDataTypeScalarType(type) == glu::TYPE_FLOAT; 1667 1668 for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) 1669 { 1670 glu::Precision precision = precisions[precNdx]; 1671 1672 string name = string(glu::getPrecisionName(precision)) + "_" + glu::getDataTypeName(type); 1673 primitiveGroup->addChild(new BasicTypeCase(m_context, name.c_str(), "", bufferMode, primitiveType, type, precision, isFloat ? INTERPOLATION_SMOOTH : INTERPOLATION_FLAT)); 1674 } 1675 } 1676 } 1677 } 1678 } 1679 1680 // .array 1681 { 1682 tcu::TestCaseGroup* arrayGroup = new tcu::TestCaseGroup(m_testCtx, "array", "Capturing whole array in TF"); 1683 addChild(arrayGroup); 1684 1685 for (int bufferModeNdx = 0; bufferModeNdx < DE_LENGTH_OF_ARRAY(bufferModes); bufferModeNdx++) 1686 { 1687 tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[bufferModeNdx].name, ""); 1688 deUint32 bufferMode = bufferModes[bufferModeNdx].mode; 1689 arrayGroup->addChild(modeGroup); 1690 1691 for (int primitiveTypeNdx = 0; primitiveTypeNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveTypeNdx++) 1692 { 1693 tcu::TestCaseGroup* primitiveGroup = new tcu::TestCaseGroup(m_testCtx, primitiveTypes[primitiveTypeNdx].name, ""); 1694 deUint32 primitiveType = primitiveTypes[primitiveTypeNdx].type; 1695 modeGroup->addChild(primitiveGroup); 1696 1697 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(basicTypes); typeNdx++) 1698 { 1699 glu::DataType type = basicTypes[typeNdx]; 1700 bool isFloat = glu::getDataTypeScalarType(type) == glu::TYPE_FLOAT; 1701 1702 for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) 1703 { 1704 glu::Precision precision = precisions[precNdx]; 1705 1706 string name = string(glu::getPrecisionName(precision)) + "_" + glu::getDataTypeName(type); 1707 primitiveGroup->addChild(new BasicArrayCase(m_context, name.c_str(), "", bufferMode, primitiveType, type, precision, isFloat ? INTERPOLATION_SMOOTH : INTERPOLATION_FLAT)); 1708 } 1709 } 1710 } 1711 } 1712 } 1713 1714 // .array_element 1715 { 1716 tcu::TestCaseGroup* arrayElemGroup = new tcu::TestCaseGroup(m_testCtx, "array_element", "Capturing single array element in TF"); 1717 addChild(arrayElemGroup); 1718 1719 for (int bufferModeNdx = 0; bufferModeNdx < DE_LENGTH_OF_ARRAY(bufferModes); bufferModeNdx++) 1720 { 1721 tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[bufferModeNdx].name, ""); 1722 deUint32 bufferMode = bufferModes[bufferModeNdx].mode; 1723 arrayElemGroup->addChild(modeGroup); 1724 1725 for (int primitiveTypeNdx = 0; primitiveTypeNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveTypeNdx++) 1726 { 1727 tcu::TestCaseGroup* primitiveGroup = new tcu::TestCaseGroup(m_testCtx, primitiveTypes[primitiveTypeNdx].name, ""); 1728 deUint32 primitiveType = primitiveTypes[primitiveTypeNdx].type; 1729 modeGroup->addChild(primitiveGroup); 1730 1731 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(basicTypes); typeNdx++) 1732 { 1733 glu::DataType type = basicTypes[typeNdx]; 1734 bool isFloat = glu::getDataTypeScalarType(type) == glu::TYPE_FLOAT; 1735 1736 for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) 1737 { 1738 glu::Precision precision = precisions[precNdx]; 1739 1740 string name = string(glu::getPrecisionName(precision)) + "_" + glu::getDataTypeName(type); 1741 primitiveGroup->addChild(new ArrayElementCase(m_context, name.c_str(), "", bufferMode, primitiveType, type, precision, isFloat ? INTERPOLATION_SMOOTH : INTERPOLATION_FLAT)); 1742 } 1743 } 1744 } 1745 } 1746 } 1747 1748 // .interpolation 1749 { 1750 tcu::TestCaseGroup* interpolationGroup = new tcu::TestCaseGroup(m_testCtx, "interpolation", "Different interpolation modes in transform feedback varyings"); 1751 addChild(interpolationGroup); 1752 1753 for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(interpModes); modeNdx++) 1754 { 1755 Interpolation interp = interpModes[modeNdx].interp; 1756 tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, interpModes[modeNdx].name, ""); 1757 1758 interpolationGroup->addChild(modeGroup); 1759 1760 for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) 1761 { 1762 glu::Precision precision = precisions[precNdx]; 1763 1764 for (int primitiveType = 0; primitiveType < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveType++) 1765 { 1766 for (int bufferMode = 0; bufferMode < DE_LENGTH_OF_ARRAY(bufferModes); bufferMode++) 1767 { 1768 string name = string(glu::getPrecisionName(precision)) + "_vec4_" + primitiveTypes[primitiveType].name + "_" + bufferModes[bufferMode].name; 1769 modeGroup->addChild(new BasicTypeCase(m_context, name.c_str(), "", bufferModes[bufferMode].mode, primitiveTypes[primitiveType].type, glu::TYPE_FLOAT_VEC4, precision, interp)); 1770 } 1771 } 1772 } 1773 } 1774 } 1775 1776 // .random 1777 { 1778 tcu::TestCaseGroup* randomGroup = new tcu::TestCaseGroup(m_testCtx, "random", "Randomized transform feedback cases"); 1779 addChild(randomGroup); 1780 1781 for (int bufferModeNdx = 0; bufferModeNdx < DE_LENGTH_OF_ARRAY(bufferModes); bufferModeNdx++) 1782 { 1783 tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[bufferModeNdx].name, ""); 1784 deUint32 bufferMode = bufferModes[bufferModeNdx].mode; 1785 randomGroup->addChild(modeGroup); 1786 1787 for (int primitiveTypeNdx = 0; primitiveTypeNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveTypeNdx++) 1788 { 1789 tcu::TestCaseGroup* primitiveGroup = new tcu::TestCaseGroup(m_testCtx, primitiveTypes[primitiveTypeNdx].name, ""); 1790 deUint32 primitiveType = primitiveTypes[primitiveTypeNdx].type; 1791 modeGroup->addChild(primitiveGroup); 1792 1793 for (int ndx = 0; ndx < 10; ndx++) 1794 { 1795 deUint32 seed = deInt32Hash(bufferMode) ^ deInt32Hash(primitiveType) ^ deInt32Hash(ndx); 1796 primitiveGroup->addChild(new RandomCase(m_context, de::toString(ndx+1).c_str(), "", bufferMode, primitiveType, seed)); 1797 } 1798 } 1799 } 1800 } 1801 } 1802 1803 } // Functional 1804 } // gles3 1805 } // deqp 1806
