1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 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 Program interface query tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fProgramInterfaceQueryTests.hpp" 25 #include "es31fProgramInterfaceQueryTestCase.hpp" 26 #include "es31fProgramInterfaceDefinition.hpp" 27 #include "es31fProgramInterfaceDefinitionUtil.hpp" 28 #include "tcuTestLog.hpp" 29 #include "gluShaderProgram.hpp" 30 #include "gluVarTypeUtil.hpp" 31 #include "gluStrUtil.hpp" 32 #include "gluContextInfo.hpp" 33 #include "glwFunctions.hpp" 34 #include "glwEnums.hpp" 35 #include "deRandom.hpp" 36 #include "deString.h" 37 #include "deStringUtil.hpp" 38 #include "deSharedPtr.hpp" 39 #include "deUniquePtr.hpp" 40 #include "deSTLUtil.hpp" 41 #include "deArrayUtil.hpp" 42 43 #include <set> 44 #include <map> 45 46 namespace deqp 47 { 48 namespace gles31 49 { 50 namespace Functional 51 { 52 namespace 53 { 54 55 static int getTypeSize (glu::DataType type) 56 { 57 if (type == glu::TYPE_FLOAT) 58 return 4; 59 else if (type == glu::TYPE_INT || type == glu::TYPE_UINT) 60 return 4; 61 else if (type == glu::TYPE_BOOL) 62 return 4; // uint 63 64 DE_ASSERT(false); 65 return 0; 66 } 67 68 static int getVarTypeSize (const glu::VarType& type) 69 { 70 if (type.isBasicType()) 71 return glu::getDataTypeScalarSize(type.getBasicType()) * getTypeSize(glu::getDataTypeScalarType(type.getBasicType())); 72 else if (type.isStructType()) 73 { 74 int size = 0; 75 for (int ndx = 0; ndx < type.getStructPtr()->getNumMembers(); ++ndx) 76 size += getVarTypeSize(type.getStructPtr()->getMember(ndx).getType()); 77 return size; 78 } 79 else if (type.isArrayType()) 80 { 81 if (type.getArraySize() == glu::VarType::UNSIZED_ARRAY) 82 return getVarTypeSize(type.getElementType()); 83 else 84 return type.getArraySize() * getVarTypeSize(type.getElementType()); 85 } 86 else 87 { 88 DE_ASSERT(false); 89 return 0; 90 } 91 } 92 93 static std::string convertGLTypeNameToTestName (const char* glName) 94 { 95 // vectors and matrices are fine as is 96 { 97 if (deStringBeginsWith(glName, "vec") == DE_TRUE || 98 deStringBeginsWith(glName, "ivec") == DE_TRUE || 99 deStringBeginsWith(glName, "uvec") == DE_TRUE || 100 deStringBeginsWith(glName, "bvec") == DE_TRUE || 101 deStringBeginsWith(glName, "mat") == DE_TRUE) 102 return std::string(glName); 103 } 104 105 // convert camel case to use underscore 106 { 107 std::ostringstream buf; 108 std::istringstream name (glName); 109 bool mergeNextToken = false; 110 bool previousTokenWasDigit = false; 111 112 while (!name.eof()) 113 { 114 std::ostringstream token; 115 116 while (name.peek() != EOF) 117 { 118 if ((de::isDigit((char)name.peek()) || de::isUpper((char)name.peek())) && token.tellp()) 119 break; 120 121 token << de::toLower((char)name.get()); 122 } 123 124 if (buf.str().empty() || mergeNextToken) 125 buf << token.str(); 126 else 127 buf << '_' << token.str(); 128 129 // Single char causes next char to be merged (don't split initialisms or acronyms) unless it is 'D' after a number (split to ..._2d_acronym_aa 130 mergeNextToken = false; 131 if (token.tellp() == (std::streamoff)1) 132 { 133 if (!previousTokenWasDigit || token.str()[0] != 'd') 134 mergeNextToken = true; 135 136 previousTokenWasDigit = de::isDigit(token.str()[0]); 137 } 138 else 139 previousTokenWasDigit = false; 140 } 141 142 return buf.str(); 143 } 144 } 145 146 static glw::GLenum getProgramInterfaceGLEnum (ProgramInterface interface) 147 { 148 static const glw::GLenum s_enums[] = 149 { 150 GL_UNIFORM, // PROGRAMINTERFACE_UNIFORM 151 GL_UNIFORM_BLOCK, // PROGRAMINTERFACE_UNIFORM_BLOCK 152 GL_ATOMIC_COUNTER_BUFFER, // PROGRAMINTERFACE_ATOMIC_COUNTER_BUFFER 153 GL_PROGRAM_INPUT, // PROGRAMINTERFACE_PROGRAM_INPUT 154 GL_PROGRAM_OUTPUT, // PROGRAMINTERFACE_PROGRAM_OUTPUT 155 GL_TRANSFORM_FEEDBACK_VARYING, // PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING 156 GL_BUFFER_VARIABLE, // PROGRAMINTERFACE_BUFFER_VARIABLE 157 GL_SHADER_STORAGE_BLOCK, // PROGRAMINTERFACE_SHADER_STORAGE_BLOCK 158 }; 159 160 return de::getSizedArrayElement<PROGRAMINTERFACE_LAST>(s_enums, interface); 161 } 162 163 static glu::ShaderType getShaderMaskFirstStage (deUint32 mask) 164 { 165 if (mask & (1u << glu::SHADERTYPE_COMPUTE)) 166 return glu::SHADERTYPE_COMPUTE; 167 168 if (mask & (1u << glu::SHADERTYPE_VERTEX)) 169 return glu::SHADERTYPE_VERTEX; 170 171 if (mask & (1u << glu::SHADERTYPE_TESSELLATION_CONTROL)) 172 return glu::SHADERTYPE_TESSELLATION_CONTROL; 173 174 if (mask & (1u << glu::SHADERTYPE_TESSELLATION_EVALUATION)) 175 return glu::SHADERTYPE_TESSELLATION_EVALUATION; 176 177 if (mask & (1u << glu::SHADERTYPE_GEOMETRY)) 178 return glu::SHADERTYPE_GEOMETRY; 179 180 if (mask & (1u << glu::SHADERTYPE_FRAGMENT)) 181 return glu::SHADERTYPE_FRAGMENT; 182 183 DE_ASSERT(false); 184 return glu::SHADERTYPE_LAST; 185 } 186 187 static glu::ShaderType getShaderMaskLastStage (deUint32 mask) 188 { 189 if (mask & (1u << glu::SHADERTYPE_FRAGMENT)) 190 return glu::SHADERTYPE_FRAGMENT; 191 192 if (mask & (1u << glu::SHADERTYPE_GEOMETRY)) 193 return glu::SHADERTYPE_GEOMETRY; 194 195 if (mask & (1u << glu::SHADERTYPE_TESSELLATION_EVALUATION)) 196 return glu::SHADERTYPE_TESSELLATION_EVALUATION; 197 198 if (mask & (1u << glu::SHADERTYPE_TESSELLATION_CONTROL)) 199 return glu::SHADERTYPE_TESSELLATION_CONTROL; 200 201 if (mask & (1u << glu::SHADERTYPE_VERTEX)) 202 return glu::SHADERTYPE_VERTEX; 203 204 if (mask & (1u << glu::SHADERTYPE_COMPUTE)) 205 return glu::SHADERTYPE_COMPUTE; 206 207 DE_ASSERT(false); 208 return glu::SHADERTYPE_LAST; 209 } 210 211 namespace ResourceDefinition 212 { 213 214 class Node 215 { 216 public: 217 enum NodeType 218 { 219 TYPE_PROGRAM = 0, 220 TYPE_SHADER, 221 TYPE_DEFAULT_BLOCK, 222 TYPE_VARIABLE, 223 TYPE_INTERFACE_BLOCK, 224 TYPE_ARRAY_ELEMENT, 225 TYPE_STRUCT_MEMBER, 226 TYPE_STORAGE_QUALIFIER, 227 TYPE_LAYOUT_QUALIFIER, 228 TYPE_SHADER_SET, 229 TYPE_INTERPOLATION_QUALIFIER, 230 TYPE_TRANSFORM_FEEDBACK_TARGET, 231 232 TYPE_LAST 233 }; 234 235 typedef de::SharedPtr<const Node> SharedPtr; 236 237 Node (NodeType type, const SharedPtr& enclosingNode) : m_type(type), m_enclosingNode(enclosingNode) { DE_ASSERT(type < TYPE_LAST); } 238 virtual ~Node (void) { } 239 240 inline const Node* getEnclosingNode (void) const { return m_enclosingNode.get(); } 241 inline NodeType getType (void) const { return m_type; } 242 243 private: 244 const NodeType m_type; 245 const SharedPtr m_enclosingNode; 246 }; 247 248 class Program : public Node 249 { 250 public: 251 Program (bool separable = false) 252 : Node (TYPE_PROGRAM, SharedPtr()) 253 , m_separable (separable) 254 { 255 } 256 257 const bool m_separable; 258 }; 259 260 class Shader : public Node 261 { 262 public: 263 Shader (const SharedPtr& enclosingNode, glu::ShaderType type, glu::GLSLVersion version) 264 : Node (TYPE_SHADER, enclosingNode) 265 , m_type (type) 266 , m_version (version) 267 { 268 DE_ASSERT(enclosingNode->getType() == TYPE_PROGRAM); 269 DE_ASSERT(type < glu::SHADERTYPE_LAST); 270 } 271 272 const glu::ShaderType m_type; 273 const glu::GLSLVersion m_version; 274 }; 275 276 class DefaultBlock : public Node 277 { 278 public: 279 DefaultBlock (const SharedPtr& enclosing) 280 : Node(TYPE_DEFAULT_BLOCK, enclosing) 281 { 282 // enclosed by the shader 283 DE_ASSERT(enclosing->getType() == TYPE_SHADER || 284 enclosing->getType() == TYPE_SHADER_SET); 285 } 286 }; 287 288 class StorageQualifier : public Node 289 { 290 public: 291 StorageQualifier (const SharedPtr& enclosing, glu::Storage storage) 292 : Node (TYPE_STORAGE_QUALIFIER, enclosing) 293 , m_storage (storage) 294 { 295 // not a part of any block 296 DE_ASSERT(enclosing->getType() == TYPE_DEFAULT_BLOCK); 297 } 298 299 const glu::Storage m_storage; 300 }; 301 302 class Variable : public Node 303 { 304 public: 305 Variable (const SharedPtr& enclosing, glu::DataType dataType) 306 : Node (TYPE_VARIABLE, enclosing) 307 , m_dataType (dataType) 308 { 309 DE_ASSERT(enclosing->getType() == TYPE_STORAGE_QUALIFIER || 310 enclosing->getType() == TYPE_LAYOUT_QUALIFIER || 311 enclosing->getType() == TYPE_INTERPOLATION_QUALIFIER || 312 enclosing->getType() == TYPE_INTERFACE_BLOCK || 313 enclosing->getType() == TYPE_ARRAY_ELEMENT || 314 enclosing->getType() == TYPE_STRUCT_MEMBER || 315 enclosing->getType() == TYPE_TRANSFORM_FEEDBACK_TARGET); 316 } 317 318 const glu::DataType m_dataType; 319 }; 320 321 class InterfaceBlock : public Node 322 { 323 public: 324 InterfaceBlock (const SharedPtr& enclosing, bool named) 325 : Node (TYPE_INTERFACE_BLOCK, enclosing) 326 , m_named (named) 327 { 328 // Must be storage qualified 329 const Node* storageNode = enclosing.get(); 330 while (storageNode->getType() == TYPE_ARRAY_ELEMENT || 331 storageNode->getType() == TYPE_LAYOUT_QUALIFIER) 332 { 333 storageNode = storageNode->getEnclosingNode(); 334 } 335 336 DE_ASSERT(storageNode->getType() == TYPE_STORAGE_QUALIFIER); 337 DE_UNREF(storageNode); 338 } 339 340 const bool m_named; 341 }; 342 343 class ArrayElement : public Node 344 { 345 public: 346 ArrayElement (const SharedPtr& enclosing, int arraySize = DEFAULT_SIZE) 347 : Node (TYPE_ARRAY_ELEMENT, enclosing) 348 , m_arraySize (arraySize) 349 { 350 DE_ASSERT(enclosing->getType() == TYPE_STORAGE_QUALIFIER || 351 enclosing->getType() == TYPE_LAYOUT_QUALIFIER || 352 enclosing->getType() == TYPE_INTERPOLATION_QUALIFIER || 353 enclosing->getType() == TYPE_INTERFACE_BLOCK || 354 enclosing->getType() == TYPE_ARRAY_ELEMENT || 355 enclosing->getType() == TYPE_STRUCT_MEMBER || 356 enclosing->getType() == TYPE_TRANSFORM_FEEDBACK_TARGET); 357 } 358 359 const int m_arraySize; 360 361 enum 362 { 363 DEFAULT_SIZE = -1, 364 UNSIZED_ARRAY = -2, 365 }; 366 }; 367 368 class StructMember : public Node 369 { 370 public: 371 StructMember (const SharedPtr& enclosing) 372 : Node(TYPE_STRUCT_MEMBER, enclosing) 373 { 374 DE_ASSERT(enclosing->getType() == TYPE_STORAGE_QUALIFIER || 375 enclosing->getType() == TYPE_LAYOUT_QUALIFIER || 376 enclosing->getType() == TYPE_INTERPOLATION_QUALIFIER || 377 enclosing->getType() == TYPE_INTERFACE_BLOCK || 378 enclosing->getType() == TYPE_ARRAY_ELEMENT || 379 enclosing->getType() == TYPE_STRUCT_MEMBER || 380 enclosing->getType() == TYPE_TRANSFORM_FEEDBACK_TARGET); 381 } 382 }; 383 384 class LayoutQualifier : public Node 385 { 386 public: 387 LayoutQualifier (const SharedPtr& enclosing, const glu::Layout& layout) 388 : Node (TYPE_LAYOUT_QUALIFIER, enclosing) 389 , m_layout (layout) 390 { 391 DE_ASSERT(enclosing->getType() == TYPE_STORAGE_QUALIFIER || 392 enclosing->getType() == TYPE_LAYOUT_QUALIFIER || 393 enclosing->getType() == TYPE_INTERPOLATION_QUALIFIER || 394 enclosing->getType() == TYPE_DEFAULT_BLOCK || 395 enclosing->getType() == TYPE_INTERFACE_BLOCK); 396 } 397 398 const glu::Layout m_layout; 399 }; 400 401 class InterpolationQualifier : public Node 402 { 403 public: 404 InterpolationQualifier (const SharedPtr& enclosing, const glu::Interpolation& interpolation) 405 : Node (TYPE_INTERPOLATION_QUALIFIER, enclosing) 406 , m_interpolation (interpolation) 407 { 408 DE_ASSERT(enclosing->getType() == TYPE_STORAGE_QUALIFIER || 409 enclosing->getType() == TYPE_LAYOUT_QUALIFIER || 410 enclosing->getType() == TYPE_INTERPOLATION_QUALIFIER || 411 enclosing->getType() == TYPE_DEFAULT_BLOCK || 412 enclosing->getType() == TYPE_INTERFACE_BLOCK); 413 } 414 415 const glu::Interpolation m_interpolation; 416 }; 417 418 class ShaderSet : public Node 419 { 420 public: 421 ShaderSet (const SharedPtr& enclosing, glu::GLSLVersion version); 422 ShaderSet (const SharedPtr& enclosing, glu::GLSLVersion version, deUint32 stagesPresentBits, deUint32 stagesReferencingBits); 423 424 void setStage (glu::ShaderType type, bool referencing); 425 bool isStagePresent (glu::ShaderType stage) const; 426 bool isStageReferencing (glu::ShaderType stage) const; 427 428 deUint32 getReferencingMask (void) const; 429 430 const glu::GLSLVersion m_version; 431 private: 432 bool m_stagePresent[glu::SHADERTYPE_LAST]; 433 bool m_stageReferencing[glu::SHADERTYPE_LAST]; 434 }; 435 436 ShaderSet::ShaderSet (const SharedPtr& enclosing, glu::GLSLVersion version) 437 : Node (TYPE_SHADER_SET, enclosing) 438 , m_version (version) 439 { 440 DE_ASSERT(enclosing->getType() == TYPE_PROGRAM); 441 442 deMemset(m_stagePresent, 0, sizeof(m_stagePresent)); 443 deMemset(m_stageReferencing, 0, sizeof(m_stageReferencing)); 444 } 445 446 ShaderSet::ShaderSet (const SharedPtr& enclosing, 447 glu::GLSLVersion version, 448 deUint32 stagesPresentBits, 449 deUint32 stagesReferencingBits) 450 : Node (TYPE_SHADER_SET, enclosing) 451 , m_version (version) 452 { 453 for (deUint32 stageNdx = 0; stageNdx < glu::SHADERTYPE_LAST; ++stageNdx) 454 { 455 const deUint32 stageMask = (1u << stageNdx); 456 const bool stagePresent = (stagesPresentBits & stageMask) != 0; 457 const bool stageReferencing = (stagesReferencingBits & stageMask) != 0; 458 459 DE_ASSERT(stagePresent || !stageReferencing); 460 461 m_stagePresent[stageNdx] = stagePresent; 462 m_stageReferencing[stageNdx] = stageReferencing; 463 } 464 } 465 466 void ShaderSet::setStage (glu::ShaderType type, bool referencing) 467 { 468 DE_ASSERT(type < glu::SHADERTYPE_LAST); 469 m_stagePresent[type] = true; 470 m_stageReferencing[type] = referencing; 471 } 472 473 bool ShaderSet::isStagePresent (glu::ShaderType stage) const 474 { 475 DE_ASSERT(stage < glu::SHADERTYPE_LAST); 476 return m_stagePresent[stage]; 477 } 478 479 bool ShaderSet::isStageReferencing (glu::ShaderType stage) const 480 { 481 DE_ASSERT(stage < glu::SHADERTYPE_LAST); 482 return m_stageReferencing[stage]; 483 } 484 485 deUint32 ShaderSet::getReferencingMask (void) const 486 { 487 deUint32 mask = 0; 488 for (deUint32 stage = 0; stage < glu::SHADERTYPE_LAST; ++stage) 489 { 490 if (m_stageReferencing[stage]) 491 mask |= (1u << stage); 492 } 493 return mask; 494 } 495 496 class TransformFeedbackTarget : public Node 497 { 498 public: 499 TransformFeedbackTarget (const SharedPtr& enclosing, const char* builtinVarName = DE_NULL) 500 : Node (TYPE_TRANSFORM_FEEDBACK_TARGET, enclosing) 501 , m_builtinVarName (builtinVarName) 502 { 503 } 504 505 const char* const m_builtinVarName; 506 }; 507 508 } // ResourceDefinition 509 510 static glu::Precision getDataTypeDefaultPrecision (const glu::DataType& type) 511 { 512 if (glu::isDataTypeBoolOrBVec(type)) 513 return glu::PRECISION_LAST; 514 else if (glu::isDataTypeScalarOrVector(type) || glu::isDataTypeMatrix(type)) 515 return glu::PRECISION_HIGHP; 516 else if (glu::isDataTypeSampler(type)) 517 return glu::PRECISION_HIGHP; 518 else if (glu::isDataTypeImage(type)) 519 return glu::PRECISION_HIGHP; 520 else if (type == glu::TYPE_UINT_ATOMIC_COUNTER) 521 return glu::PRECISION_HIGHP; 522 523 DE_ASSERT(false); 524 return glu::PRECISION_LAST; 525 } 526 527 static de::MovePtr<ProgramInterfaceDefinition::Program> generateProgramDefinitionFromResource (const ResourceDefinition::Node* resource) 528 { 529 de::MovePtr<ProgramInterfaceDefinition::Program> program (new ProgramInterfaceDefinition::Program()); 530 const ResourceDefinition::Node* head = resource; 531 532 if (head->getType() == ResourceDefinition::Node::TYPE_VARIABLE) 533 { 534 DE_ASSERT(dynamic_cast<const ResourceDefinition::Variable*>(resource)); 535 536 enum BindingType 537 { 538 BINDING_VARIABLE, 539 BINDING_INTERFACE_BLOCK, 540 BINDING_DEFAULT_BLOCK 541 }; 542 543 int structNdx = 0; 544 int autoAssignArraySize = 0; 545 const glu::DataType basicType = static_cast<const ResourceDefinition::Variable*>(resource)->m_dataType; 546 BindingType boundObject = BINDING_VARIABLE; 547 glu::VariableDeclaration variable (glu::VarType(basicType, getDataTypeDefaultPrecision(basicType)), "target"); 548 glu::InterfaceBlock interfaceBlock; 549 ProgramInterfaceDefinition::DefaultBlock defaultBlock; 550 std::vector<std::string> feedbackTargetVaryingPath; 551 bool feedbackTargetSet = false; 552 553 // image specific 554 if (glu::isDataTypeImage(basicType)) 555 { 556 variable.memoryAccessQualifierBits |= glu::MEMORYACCESSQUALIFIER_READONLY_BIT; 557 variable.layout.binding = 1; 558 559 if (basicType >= glu::TYPE_IMAGE_2D && basicType <= glu::TYPE_IMAGE_3D) 560 variable.layout.format = glu::FORMATLAYOUT_RGBA8; 561 else if (basicType >= glu::TYPE_INT_IMAGE_2D && basicType <= glu::TYPE_INT_IMAGE_3D) 562 variable.layout.format = glu::FORMATLAYOUT_RGBA8I; 563 else if (basicType >= glu::TYPE_UINT_IMAGE_2D && basicType <= glu::TYPE_UINT_IMAGE_3D) 564 variable.layout.format = glu::FORMATLAYOUT_RGBA8UI; 565 else 566 DE_ASSERT(false); 567 } 568 569 // atomic counter specific 570 if (basicType == glu::TYPE_UINT_ATOMIC_COUNTER) 571 variable.layout.binding = 1; 572 573 for (head = head->getEnclosingNode(); head; head = head->getEnclosingNode()) 574 { 575 if (head->getType() == ResourceDefinition::Node::TYPE_STORAGE_QUALIFIER) 576 { 577 const ResourceDefinition::StorageQualifier* qualifier = static_cast<const ResourceDefinition::StorageQualifier*>(head); 578 579 DE_ASSERT(dynamic_cast<const ResourceDefinition::StorageQualifier*>(head)); 580 581 if (boundObject == BINDING_VARIABLE) 582 { 583 DE_ASSERT(variable.storage == glu::STORAGE_LAST); 584 variable.storage = qualifier->m_storage; 585 } 586 else if (boundObject == BINDING_INTERFACE_BLOCK) 587 { 588 DE_ASSERT(interfaceBlock.storage == glu::STORAGE_LAST); 589 interfaceBlock.storage = qualifier->m_storage; 590 } 591 else 592 DE_ASSERT(false); 593 } 594 else if (head->getType() == ResourceDefinition::Node::TYPE_LAYOUT_QUALIFIER) 595 { 596 const ResourceDefinition::LayoutQualifier* qualifier = static_cast<const ResourceDefinition::LayoutQualifier*>(head); 597 glu::Layout* targetLayout = DE_NULL; 598 599 DE_ASSERT(dynamic_cast<const ResourceDefinition::LayoutQualifier*>(head)); 600 601 if (boundObject == BINDING_VARIABLE) 602 targetLayout = &variable.layout; 603 else if (boundObject == BINDING_INTERFACE_BLOCK) 604 targetLayout = &interfaceBlock.layout; 605 else 606 DE_ASSERT(false); 607 608 if (qualifier->m_layout.location != -1) 609 targetLayout->location = qualifier->m_layout.location; 610 611 if (qualifier->m_layout.binding != -1) 612 targetLayout->binding = qualifier->m_layout.binding; 613 614 if (qualifier->m_layout.offset != -1) 615 targetLayout->offset = qualifier->m_layout.offset; 616 617 if (qualifier->m_layout.format != glu::FORMATLAYOUT_LAST) 618 targetLayout->format = qualifier->m_layout.format; 619 620 if (qualifier->m_layout.matrixOrder != glu::MATRIXORDER_LAST) 621 targetLayout->matrixOrder = qualifier->m_layout.matrixOrder; 622 } 623 else if (head->getType() == ResourceDefinition::Node::TYPE_INTERPOLATION_QUALIFIER) 624 { 625 const ResourceDefinition::InterpolationQualifier* qualifier = static_cast<const ResourceDefinition::InterpolationQualifier*>(head); 626 627 DE_ASSERT(dynamic_cast<const ResourceDefinition::InterpolationQualifier*>(head)); 628 629 if (boundObject == BINDING_VARIABLE) 630 variable.interpolation = qualifier->m_interpolation; 631 else 632 DE_ASSERT(false); 633 } 634 else if (head->getType() == ResourceDefinition::Node::TYPE_ARRAY_ELEMENT) 635 { 636 DE_ASSERT(dynamic_cast<const ResourceDefinition::ArrayElement*>(head)); 637 638 const ResourceDefinition::ArrayElement* arrayElement = static_cast<const ResourceDefinition::ArrayElement*>(head); 639 int arraySize; 640 641 // Vary array size per level 642 if (arrayElement->m_arraySize == ResourceDefinition::ArrayElement::DEFAULT_SIZE) 643 { 644 if (--autoAssignArraySize <= 1) 645 autoAssignArraySize = 3; 646 647 arraySize = autoAssignArraySize; 648 } 649 else if (arrayElement->m_arraySize == ResourceDefinition::ArrayElement::UNSIZED_ARRAY) 650 arraySize = glu::VarType::UNSIZED_ARRAY; 651 else 652 arraySize = arrayElement->m_arraySize; 653 654 if (boundObject == BINDING_VARIABLE) 655 variable.varType = glu::VarType(variable.varType, arraySize); 656 else if (boundObject == BINDING_INTERFACE_BLOCK) 657 interfaceBlock.dimensions.push_back(arraySize); 658 else 659 DE_ASSERT(false); 660 661 if (feedbackTargetSet) 662 feedbackTargetVaryingPath.back().append("[0]"); 663 } 664 else if (head->getType() == ResourceDefinition::Node::TYPE_STRUCT_MEMBER) 665 { 666 DE_ASSERT(dynamic_cast<const ResourceDefinition::StructMember*>(head)); 667 DE_ASSERT(boundObject == BINDING_VARIABLE); 668 669 // Struct members cannot contain any qualifiers except precision 670 DE_ASSERT(variable.interpolation == glu::INTERPOLATION_LAST); 671 DE_ASSERT(variable.layout == glu::Layout()); 672 DE_ASSERT(variable.memoryAccessQualifierBits == 0); 673 DE_ASSERT(variable.storage == glu::STORAGE_LAST); 674 675 { 676 glu::StructType* structPtr = new glu::StructType(("StructType" + de::toString(structNdx++)).c_str()); 677 structPtr->addMember(variable.name.c_str(), variable.varType); 678 679 variable = glu::VariableDeclaration(glu::VarType(structPtr), "target"); 680 } 681 682 if (feedbackTargetSet) 683 feedbackTargetVaryingPath.push_back("target"); 684 } 685 else if (head->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK) 686 { 687 DE_ASSERT(dynamic_cast<const ResourceDefinition::InterfaceBlock*>(head)); 688 DE_ASSERT(boundObject == BINDING_VARIABLE); 689 690 const bool named = static_cast<const ResourceDefinition::InterfaceBlock*>(head)->m_named; 691 692 boundObject = BINDING_INTERFACE_BLOCK; 693 694 interfaceBlock.interfaceName = "TargetInterface"; 695 interfaceBlock.instanceName = (named) ? ("targetInstance") : (""); 696 interfaceBlock.variables.push_back(variable); 697 698 if (feedbackTargetSet && !interfaceBlock.instanceName.empty()) 699 feedbackTargetVaryingPath.push_back(interfaceBlock.interfaceName); 700 } 701 else if (head->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK) 702 { 703 DE_ASSERT(dynamic_cast<const ResourceDefinition::DefaultBlock*>(head)); 704 DE_ASSERT(boundObject == BINDING_VARIABLE || boundObject == BINDING_INTERFACE_BLOCK); 705 706 if (boundObject == BINDING_VARIABLE) 707 defaultBlock.variables.push_back(variable); 708 else if (boundObject == BINDING_INTERFACE_BLOCK) 709 defaultBlock.interfaceBlocks.push_back(interfaceBlock); 710 else 711 DE_ASSERT(false); 712 713 boundObject = BINDING_DEFAULT_BLOCK; 714 } 715 else if (head->getType() == ResourceDefinition::Node::TYPE_SHADER) 716 { 717 DE_ASSERT(dynamic_cast<const ResourceDefinition::Shader*>(head)); 718 719 const ResourceDefinition::Shader* shaderDef = static_cast<const ResourceDefinition::Shader*>(head); 720 ProgramInterfaceDefinition::Shader* shader = program->addShader(shaderDef->m_type, shaderDef->m_version); 721 722 shader->getDefaultBlock() = defaultBlock; 723 } 724 else if (head->getType() == ResourceDefinition::Node::TYPE_SHADER_SET) 725 { 726 DE_ASSERT(dynamic_cast<const ResourceDefinition::ShaderSet*>(head)); 727 728 const ResourceDefinition::ShaderSet* shaderDef = static_cast<const ResourceDefinition::ShaderSet*>(head); 729 730 for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; ++shaderType) 731 { 732 if (shaderDef->isStagePresent((glu::ShaderType)shaderType)) 733 { 734 ProgramInterfaceDefinition::Shader* shader = program->addShader((glu::ShaderType)shaderType, shaderDef->m_version); 735 736 if (shaderDef->isStageReferencing((glu::ShaderType)shaderType)) 737 shader->getDefaultBlock() = defaultBlock; 738 } 739 } 740 } 741 else if (head->getType() == ResourceDefinition::Node::TYPE_PROGRAM) 742 { 743 DE_ASSERT(dynamic_cast<const ResourceDefinition::Program*>(head)); 744 745 const ResourceDefinition::Program* programDef = static_cast<const ResourceDefinition::Program*>(head); 746 747 program->setSeparable(programDef->m_separable); 748 749 DE_ASSERT(feedbackTargetSet == !feedbackTargetVaryingPath.empty()); 750 if (!feedbackTargetVaryingPath.empty()) 751 { 752 std::ostringstream buf; 753 754 for (std::vector<std::string>::reverse_iterator it = feedbackTargetVaryingPath.rbegin(); it != feedbackTargetVaryingPath.rend(); ++it) 755 { 756 if (it != feedbackTargetVaryingPath.rbegin()) 757 buf << "."; 758 buf << *it; 759 } 760 761 program->addTransformFeedbackVarying(buf.str()); 762 program->setTransformFeedbackMode(GL_INTERLEAVED_ATTRIBS); 763 } 764 break; 765 } 766 else if (head->getType() == ResourceDefinition::Node::TYPE_TRANSFORM_FEEDBACK_TARGET) 767 { 768 DE_ASSERT(dynamic_cast<const ResourceDefinition::TransformFeedbackTarget*>(head)); 769 770 const ResourceDefinition::TransformFeedbackTarget* feedbackTarget = static_cast<const ResourceDefinition::TransformFeedbackTarget*>(head); 771 772 DE_ASSERT(feedbackTarget->m_builtinVarName == DE_NULL); 773 DE_UNREF(feedbackTarget); 774 775 feedbackTargetSet = true; 776 feedbackTargetVaryingPath.push_back(variable.name); 777 } 778 else 779 { 780 DE_ASSERT(DE_FALSE); 781 break; 782 } 783 } 784 } 785 else if (head->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK || 786 head->getType() == ResourceDefinition::Node::TYPE_TRANSFORM_FEEDBACK_TARGET) 787 { 788 const char* feedbackTargetVaryingName = DE_NULL; 789 790 // empty default block 791 792 for (; head; head = head->getEnclosingNode()) 793 { 794 if (head->getType() == ResourceDefinition::Node::TYPE_SHADER) 795 { 796 DE_ASSERT(dynamic_cast<const ResourceDefinition::Shader*>(head)); 797 798 const ResourceDefinition::Shader* shaderDef = static_cast<const ResourceDefinition::Shader*>(head); 799 800 program->addShader(shaderDef->m_type, shaderDef->m_version); 801 } 802 else if (head->getType() == ResourceDefinition::Node::TYPE_SHADER_SET) 803 { 804 DE_ASSERT(dynamic_cast<const ResourceDefinition::ShaderSet*>(head)); 805 806 const ResourceDefinition::ShaderSet* shaderDef = static_cast<const ResourceDefinition::ShaderSet*>(head); 807 808 for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; ++shaderType) 809 if (shaderDef->isStagePresent((glu::ShaderType)shaderType)) 810 program->addShader((glu::ShaderType)shaderType, shaderDef->m_version); 811 } 812 else if (head->getType() == ResourceDefinition::Node::TYPE_PROGRAM) 813 { 814 DE_ASSERT(dynamic_cast<const ResourceDefinition::Program*>(head)); 815 816 const ResourceDefinition::Program* programDef = static_cast<const ResourceDefinition::Program*>(head); 817 818 program->setSeparable(programDef->m_separable); 819 if (feedbackTargetVaryingName) 820 { 821 program->addTransformFeedbackVarying(std::string(feedbackTargetVaryingName)); 822 program->setTransformFeedbackMode(GL_INTERLEAVED_ATTRIBS); 823 } 824 break; 825 } 826 else if (head->getType() == ResourceDefinition::Node::TYPE_TRANSFORM_FEEDBACK_TARGET) 827 { 828 DE_ASSERT(dynamic_cast<const ResourceDefinition::TransformFeedbackTarget*>(head)); 829 830 const ResourceDefinition::TransformFeedbackTarget* feedbackTarget = static_cast<const ResourceDefinition::TransformFeedbackTarget*>(head); 831 832 DE_ASSERT(feedbackTarget->m_builtinVarName != DE_NULL); 833 834 feedbackTargetVaryingName = feedbackTarget->m_builtinVarName; 835 } 836 else if (head->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK) 837 { 838 } 839 else 840 { 841 DE_ASSERT(DE_FALSE); 842 break; 843 } 844 } 845 } 846 847 if (program->hasStage(glu::SHADERTYPE_GEOMETRY)) 848 program->setGeometryNumOutputVertices(1); 849 if (program->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || program->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION)) 850 program->setTessellationNumOutputPatchVertices(1); 851 852 return program; 853 } 854 855 static void checkAndLogProgram (const glu::ShaderProgram& program, const ProgramInterfaceDefinition::Program* programDefinition, const glw::Functions& gl, tcu::TestLog& log) 856 { 857 const tcu::ScopedLogSection section(log, "Program", "Program"); 858 859 log << program; 860 if (!program.isOk()) 861 { 862 log << tcu::TestLog::Message << "Program build failed, checking if program exceeded implementation limits" << tcu::TestLog::EndMessage; 863 checkProgramResourceUsage(programDefinition, gl, log); 864 865 // within limits 866 throw tcu::TestError("could not build program"); 867 } 868 } 869 870 // Resource list query case 871 872 class ResourceListTestCase : public TestCase 873 { 874 public: 875 ResourceListTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, ProgramInterface interface, const char* name = DE_NULL); 876 ~ResourceListTestCase (void); 877 878 protected: 879 void init (void); 880 void deinit (void); 881 IterateResult iterate (void); 882 883 void queryResourceList (std::vector<std::string>& dst, glw::GLuint program); 884 bool verifyResourceList (const std::vector<std::string>& resourceList, const std::vector<std::string>& expectedResources); 885 bool verifyResourceIndexQuery (const std::vector<std::string>& resourceList, const std::vector<std::string>& referenceResources, glw::GLuint program); 886 bool verifyMaxNameLength (const std::vector<std::string>& referenceResourceList, glw::GLuint program); 887 888 static std::string genTestCaseName (ProgramInterface interface, const ResourceDefinition::Node*); 889 static bool isArrayedInterface (ProgramInterface interface, deUint32 stageBits); 890 891 const ProgramInterface m_programInterface; 892 ResourceDefinition::Node::SharedPtr m_targetResource; 893 ProgramInterfaceDefinition::Program* m_programDefinition; 894 }; 895 896 ResourceListTestCase::ResourceListTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, ProgramInterface interface, const char* name) 897 : TestCase (context, (name == DE_NULL) ? (genTestCaseName(interface, targetResource.get()).c_str()) : (name), "") 898 , m_programInterface (interface) 899 , m_targetResource (targetResource) 900 , m_programDefinition (DE_NULL) 901 { 902 // GL_ATOMIC_COUNTER_BUFFER: no resource names 903 DE_ASSERT(m_programInterface != PROGRAMINTERFACE_ATOMIC_COUNTER_BUFFER); 904 } 905 906 ResourceListTestCase::~ResourceListTestCase (void) 907 { 908 deinit(); 909 } 910 911 void ResourceListTestCase::init (void) 912 { 913 m_programDefinition = generateProgramDefinitionFromResource(m_targetResource.get()).release(); 914 915 if ((m_programDefinition->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || m_programDefinition->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION)) && 916 !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader")) 917 { 918 throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader extension"); 919 } 920 if (m_programDefinition->hasStage(glu::SHADERTYPE_GEOMETRY) && 921 !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) 922 { 923 throw tcu::NotSupportedError("Test requires GL_EXT_geometry_shader extension"); 924 } 925 if (programContainsIOBlocks(m_programDefinition) && 926 !m_context.getContextInfo().isExtensionSupported("GL_EXT_shader_io_blocks")) 927 { 928 throw tcu::NotSupportedError("Test requires GL_EXT_shader_io_blocks extension"); 929 } 930 } 931 932 void ResourceListTestCase::deinit (void) 933 { 934 m_targetResource.clear(); 935 936 delete m_programDefinition; 937 m_programDefinition = DE_NULL; 938 } 939 940 ResourceListTestCase::IterateResult ResourceListTestCase::iterate (void) 941 { 942 const glu::ShaderProgram program(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_programDefinition)); 943 944 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 945 checkAndLogProgram(program, m_programDefinition, m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 946 947 // Check resource list 948 { 949 const tcu::ScopedLogSection section (m_testCtx.getLog(), "ResourceList", "Resource list"); 950 std::vector<std::string> resourceList; 951 std::vector<std::string> expectedResources; 952 953 queryResourceList(resourceList, program.getProgram()); 954 expectedResources = getProgramInterfaceResourceList(m_programDefinition, m_programInterface); 955 956 // verify the list and the expected list match 957 958 if (!verifyResourceList(resourceList, expectedResources)) 959 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid resource list"); 960 961 // verify GetProgramResourceIndex() matches the indices of the list 962 963 if (!verifyResourceIndexQuery(resourceList, expectedResources, program.getProgram())) 964 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "GetProgramResourceIndex returned unexpected values"); 965 966 // Verify MAX_NAME_LENGTH 967 if (!verifyMaxNameLength(resourceList, program.getProgram())) 968 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "MAX_NAME_LENGTH invalid"); 969 } 970 971 return STOP; 972 } 973 974 void ResourceListTestCase::queryResourceList (std::vector<std::string>& dst, glw::GLuint program) 975 { 976 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 977 const glw::GLenum programInterface = getProgramInterfaceGLEnum(m_programInterface); 978 glw::GLint numActiveResources = 0; 979 glw::GLint maxNameLength = 0; 980 std::vector<char> buffer; 981 982 m_testCtx.getLog() << tcu::TestLog::Message << "Querying " << glu::getProgramInterfaceName(programInterface) << " interface:" << tcu::TestLog::EndMessage; 983 984 gl.getProgramInterfaceiv(program, programInterface, GL_ACTIVE_RESOURCES, &numActiveResources); 985 gl.getProgramInterfaceiv(program, programInterface, GL_MAX_NAME_LENGTH, &maxNameLength); 986 GLU_EXPECT_NO_ERROR(gl.getError(), "query interface"); 987 988 m_testCtx.getLog() << tcu::TestLog::Message 989 << "\tGL_ACTIVE_RESOURCES = " << numActiveResources << "\n" 990 << "\tGL_MAX_NAME_LENGTH = " << maxNameLength 991 << tcu::TestLog::EndMessage; 992 993 m_testCtx.getLog() << tcu::TestLog::Message << "Querying all active resources" << tcu::TestLog::EndMessage; 994 995 buffer.resize(maxNameLength+1, '\0'); 996 997 for (int resourceNdx = 0; resourceNdx < numActiveResources; ++resourceNdx) 998 { 999 glw::GLint written = 0; 1000 1001 gl.getProgramResourceName(program, programInterface, resourceNdx, maxNameLength, &written, &buffer[0]); 1002 GLU_EXPECT_NO_ERROR(gl.getError(), "query resource name"); 1003 1004 dst.push_back(std::string(&buffer[0], written)); 1005 } 1006 } 1007 1008 bool ResourceListTestCase::verifyResourceList (const std::vector<std::string>& resourceList, const std::vector<std::string>& expectedResources) 1009 { 1010 bool error = false; 1011 1012 // Log and compare resource lists 1013 1014 m_testCtx.getLog() << tcu::TestLog::Message << "GL returned resources:" << tcu::TestLog::EndMessage; 1015 1016 for (int ndx = 0; ndx < (int)resourceList.size(); ++ndx) 1017 { 1018 // dummyZero is a uniform that may be added by 1019 // generateProgramInterfaceProgramSources. Omit it here to avoid 1020 // confusion about the output. 1021 if (resourceList[ndx] != getDummyZeroUniformName()) 1022 m_testCtx.getLog() << tcu::TestLog::Message << "\t" << ndx << ": " << resourceList[ndx] << tcu::TestLog::EndMessage; 1023 } 1024 1025 m_testCtx.getLog() << tcu::TestLog::Message << "Expected list of resources:" << tcu::TestLog::EndMessage; 1026 1027 for (int ndx = 0; ndx < (int)expectedResources.size(); ++ndx) 1028 m_testCtx.getLog() << tcu::TestLog::Message << "\t" << ndx << ": " << expectedResources[ndx] << tcu::TestLog::EndMessage; 1029 1030 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying resource list contents." << tcu::TestLog::EndMessage; 1031 1032 for (int ndx = 0; ndx < (int)expectedResources.size(); ++ndx) 1033 { 1034 if (!de::contains(resourceList.begin(), resourceList.end(), expectedResources[ndx])) 1035 { 1036 m_testCtx.getLog() << tcu::TestLog::Message << "Error, resource list did not contain active resource " << expectedResources[ndx] << tcu::TestLog::EndMessage; 1037 error = true; 1038 } 1039 } 1040 1041 for (int ndx = 0; ndx < (int)resourceList.size(); ++ndx) 1042 { 1043 if (!de::contains(expectedResources.begin(), expectedResources.end(), resourceList[ndx])) 1044 { 1045 // Ignore all builtin variables or the variable dummyZero, 1046 // mismatch causes errors otherwise. dummyZero is a uniform that 1047 // may be added by generateProgramInterfaceProgramSources. 1048 if (deStringBeginsWith(resourceList[ndx].c_str(), "gl_") == DE_FALSE && 1049 resourceList[ndx] != getDummyZeroUniformName()) 1050 { 1051 m_testCtx.getLog() << tcu::TestLog::Message << "Error, resource list contains unexpected resource name " << resourceList[ndx] << tcu::TestLog::EndMessage; 1052 error = true; 1053 } 1054 else 1055 m_testCtx.getLog() << tcu::TestLog::Message << "Note, resource list contains unknown built-in " << resourceList[ndx] << ". This variable is ignored." << tcu::TestLog::EndMessage; 1056 } 1057 } 1058 1059 return !error; 1060 } 1061 1062 bool ResourceListTestCase::verifyResourceIndexQuery (const std::vector<std::string>& resourceList, const std::vector<std::string>& referenceResources, glw::GLuint program) 1063 { 1064 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1065 const glw::GLenum programInterface = getProgramInterfaceGLEnum(m_programInterface); 1066 bool error = false; 1067 1068 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying GetProgramResourceIndex returns correct indices for resource names." << tcu::TestLog::EndMessage; 1069 1070 for (int ndx = 0; ndx < (int)referenceResources.size(); ++ndx) 1071 { 1072 const glw::GLuint index = gl.getProgramResourceIndex(program, programInterface, referenceResources[ndx].c_str()); 1073 GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index"); 1074 1075 if (index == GL_INVALID_INDEX) 1076 { 1077 m_testCtx.getLog() << tcu::TestLog::Message << "Error, for active resource \"" << referenceResources[ndx] << "\" got index GL_INVALID_INDEX." << tcu::TestLog::EndMessage; 1078 error = true; 1079 } 1080 else if ((int)index >= (int)resourceList.size()) 1081 { 1082 m_testCtx.getLog() << tcu::TestLog::Message << "Error, for active resource \"" << referenceResources[ndx] << "\" got index " << index << " (larger or equal to GL_ACTIVE_RESOURCES)." << tcu::TestLog::EndMessage; 1083 error = true; 1084 } 1085 else if (resourceList[index] != referenceResources[ndx]) 1086 { 1087 m_testCtx.getLog() << tcu::TestLog::Message << "Error, for active resource \"" << referenceResources[ndx] << "\" got index (index = " << index << ") of another resource (" << resourceList[index] << ")." << tcu::TestLog::EndMessage; 1088 error = true; 1089 } 1090 } 1091 1092 // Query for "name" should match "name[0]" except for XFB 1093 1094 if (m_programInterface != PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING) 1095 { 1096 for (int ndx = 0; ndx < (int)referenceResources.size(); ++ndx) 1097 { 1098 if (de::endsWith(referenceResources[ndx], "[0]")) 1099 { 1100 const std::string queryString = referenceResources[ndx].substr(0, referenceResources[ndx].length()-3); 1101 const glw::GLuint index = gl.getProgramResourceIndex(program, programInterface, queryString.c_str()); 1102 GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index"); 1103 1104 if (index == GL_INVALID_INDEX) 1105 { 1106 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for \"" << queryString << "\" resulted in index GL_INVALID_INDEX." << tcu::TestLog::EndMessage; 1107 error = true; 1108 } 1109 else if ((int)index >= (int)resourceList.size()) 1110 { 1111 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for \"" << queryString << "\" resulted in index " << index << " (larger or equal to GL_ACTIVE_RESOURCES)." << tcu::TestLog::EndMessage; 1112 error = true; 1113 } 1114 else if (resourceList[index] != queryString + "[0]") 1115 { 1116 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for \"" << queryString << "\" got index (index = " << index << ") of another resource (\"" << resourceList[index] << "\")." << tcu::TestLog::EndMessage; 1117 error = true; 1118 } 1119 } 1120 } 1121 } 1122 1123 return !error; 1124 } 1125 1126 bool ResourceListTestCase::verifyMaxNameLength (const std::vector<std::string>& resourceList, glw::GLuint program) 1127 { 1128 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1129 const glw::GLenum programInterface = getProgramInterfaceGLEnum(m_programInterface); 1130 glw::GLint maxNameLength = 0; 1131 glw::GLint expectedMaxNameLength = 0; 1132 1133 gl.getProgramInterfaceiv(program, programInterface, GL_MAX_NAME_LENGTH, &maxNameLength); 1134 GLU_EXPECT_NO_ERROR(gl.getError(), "query interface"); 1135 1136 for (int ndx = 0; ndx < (int)resourceList.size(); ++ndx) 1137 expectedMaxNameLength = de::max(expectedMaxNameLength, (int)resourceList[ndx].size() + 1); 1138 1139 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying MAX_NAME_LENGTH, expecting " << expectedMaxNameLength << " (i.e. consistent with the queried resource list)" << tcu::TestLog::EndMessage; 1140 1141 if (expectedMaxNameLength != maxNameLength) 1142 { 1143 m_testCtx.getLog() << tcu::TestLog::Message << "Error, got " << maxNameLength << tcu::TestLog::EndMessage; 1144 return false; 1145 } 1146 1147 return true; 1148 } 1149 1150 std::string ResourceListTestCase::genTestCaseName (ProgramInterface interface, const ResourceDefinition::Node* root) 1151 { 1152 bool isImplicitlySizedArray = false; 1153 bool hasVariable = false; 1154 bool accumulateName = true; 1155 std::string buf = "var"; 1156 std::string prefix; 1157 1158 for (const ResourceDefinition::Node* node = root; node; node = node->getEnclosingNode()) 1159 { 1160 switch (node->getType()) 1161 { 1162 case ResourceDefinition::Node::TYPE_VARIABLE: 1163 { 1164 hasVariable = true; 1165 break; 1166 } 1167 1168 case ResourceDefinition::Node::TYPE_STRUCT_MEMBER: 1169 { 1170 if (accumulateName) 1171 buf += "_struct"; 1172 break; 1173 } 1174 1175 case ResourceDefinition::Node::TYPE_ARRAY_ELEMENT: 1176 { 1177 DE_ASSERT(dynamic_cast<const ResourceDefinition::ArrayElement*>(node)); 1178 const ResourceDefinition::ArrayElement* arrayElement = static_cast<const ResourceDefinition::ArrayElement*>(node); 1179 1180 isImplicitlySizedArray = (arrayElement->m_arraySize == ResourceDefinition::ArrayElement::UNSIZED_ARRAY); 1181 1182 if (accumulateName) 1183 buf += "_array"; 1184 break; 1185 } 1186 1187 case ResourceDefinition::Node::TYPE_STORAGE_QUALIFIER: 1188 { 1189 DE_ASSERT(dynamic_cast<const ResourceDefinition::StorageQualifier*>(node)); 1190 const ResourceDefinition::StorageQualifier* storageDef = static_cast<const ResourceDefinition::StorageQualifier*>(node); 1191 1192 if (storageDef->m_storage == glu::STORAGE_PATCH_IN || 1193 storageDef->m_storage == glu::STORAGE_PATCH_OUT) 1194 { 1195 if (accumulateName) 1196 prefix += "patch_"; 1197 } 1198 break; 1199 } 1200 1201 case ResourceDefinition::Node::TYPE_SHADER: 1202 case ResourceDefinition::Node::TYPE_SHADER_SET: 1203 { 1204 bool arrayedInterface; 1205 1206 if (node->getType() == ResourceDefinition::Node::TYPE_SHADER) 1207 { 1208 DE_ASSERT(dynamic_cast<const ResourceDefinition::Shader*>(node)); 1209 const ResourceDefinition::Shader* shaderDef = static_cast<const ResourceDefinition::Shader*>(node); 1210 1211 arrayedInterface = isArrayedInterface(interface, (1u << shaderDef->m_type)); 1212 } 1213 else 1214 { 1215 DE_ASSERT(node->getType() == ResourceDefinition::Node::TYPE_SHADER_SET); 1216 DE_ASSERT(dynamic_cast<const ResourceDefinition::ShaderSet*>(node)); 1217 const ResourceDefinition::ShaderSet* shaderDef = static_cast<const ResourceDefinition::ShaderSet*>(node); 1218 1219 arrayedInterface = isArrayedInterface(interface, shaderDef->getReferencingMask()); 1220 } 1221 1222 if (arrayedInterface && isImplicitlySizedArray) 1223 { 1224 // omit implicit arrayness from name, i.e. remove trailing "_array" 1225 DE_ASSERT(de::endsWith(buf, "_array")); 1226 buf = buf.substr(0, buf.length() - 6); 1227 } 1228 1229 break; 1230 } 1231 1232 case ResourceDefinition::Node::TYPE_INTERFACE_BLOCK: 1233 { 1234 accumulateName = false; 1235 break; 1236 } 1237 1238 default: 1239 break; 1240 } 1241 } 1242 1243 if (!hasVariable) 1244 return prefix + "empty"; 1245 else 1246 return prefix + buf; 1247 } 1248 1249 bool ResourceListTestCase::isArrayedInterface (ProgramInterface interface, deUint32 stageBits) 1250 { 1251 if (interface == PROGRAMINTERFACE_PROGRAM_INPUT) 1252 { 1253 const glu::ShaderType firstStage = getShaderMaskFirstStage(stageBits); 1254 return firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL || 1255 firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION || 1256 firstStage == glu::SHADERTYPE_GEOMETRY; 1257 } 1258 else if (interface == PROGRAMINTERFACE_PROGRAM_OUTPUT) 1259 { 1260 const glu::ShaderType lastStage = getShaderMaskLastStage(stageBits); 1261 return lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL; 1262 } 1263 return false; 1264 } 1265 1266 // Resouce property query case 1267 1268 class ResourceTestCase : public ProgramInterfaceQueryTestCase 1269 { 1270 public: 1271 ResourceTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, const ProgramResourceQueryTestTarget& queryTarget, const char* name = DE_NULL); 1272 ~ResourceTestCase (void); 1273 1274 private: 1275 void init (void); 1276 void deinit (void); 1277 const ProgramInterfaceDefinition::Program* getProgramDefinition (void) const; 1278 std::vector<std::string> getQueryTargetResources (void) const; 1279 1280 static std::string genTestCaseName (const ResourceDefinition::Node*); 1281 static std::string genMultilineDescription (const ResourceDefinition::Node*); 1282 1283 ResourceDefinition::Node::SharedPtr m_targetResource; 1284 ProgramInterfaceDefinition::Program* m_program; 1285 std::vector<std::string> m_targetResources; 1286 }; 1287 1288 ResourceTestCase::ResourceTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, const ProgramResourceQueryTestTarget& queryTarget, const char* name) 1289 : ProgramInterfaceQueryTestCase (context, (name == DE_NULL) ? (genTestCaseName(targetResource.get()).c_str()) : (name), "", queryTarget) 1290 , m_targetResource (targetResource) 1291 , m_program (DE_NULL) 1292 { 1293 } 1294 1295 ResourceTestCase::~ResourceTestCase (void) 1296 { 1297 deinit(); 1298 } 1299 1300 void ResourceTestCase::init (void) 1301 { 1302 m_testCtx.getLog() 1303 << tcu::TestLog::Message 1304 << genMultilineDescription(m_targetResource.get()) 1305 << tcu::TestLog::EndMessage; 1306 1307 // Program 1308 { 1309 // Generate interface with target resource 1310 m_program = generateProgramDefinitionFromResource(m_targetResource.get()).release(); 1311 m_targetResources = getProgramInterfaceResourceList(m_program, getTargetInterface()); 1312 } 1313 } 1314 1315 void ResourceTestCase::deinit (void) 1316 { 1317 m_targetResource.clear(); 1318 1319 delete m_program; 1320 m_program = DE_NULL; 1321 1322 m_targetResources = std::vector<std::string>(); 1323 } 1324 1325 const ProgramInterfaceDefinition::Program* ResourceTestCase::getProgramDefinition (void) const 1326 { 1327 return m_program; 1328 } 1329 1330 std::vector<std::string> ResourceTestCase::getQueryTargetResources (void) const 1331 { 1332 return m_targetResources; 1333 } 1334 1335 std::string ResourceTestCase::genTestCaseName (const ResourceDefinition::Node* resource) 1336 { 1337 if (resource->getType() == ResourceDefinition::Node::TYPE_VARIABLE) 1338 { 1339 DE_ASSERT(dynamic_cast<const ResourceDefinition::Variable*>(resource)); 1340 1341 const ResourceDefinition::Variable* variable = static_cast<const ResourceDefinition::Variable*>(resource); 1342 1343 return convertGLTypeNameToTestName(glu::getDataTypeName(variable->m_dataType)); 1344 } 1345 1346 DE_ASSERT(false); 1347 return ""; 1348 } 1349 1350 std::string ResourceTestCase::genMultilineDescription (const ResourceDefinition::Node* resource) 1351 { 1352 if (resource->getType() == ResourceDefinition::Node::TYPE_VARIABLE) 1353 { 1354 DE_ASSERT(dynamic_cast<const ResourceDefinition::Variable*>(resource)); 1355 1356 const ResourceDefinition::Variable* varDef = static_cast<const ResourceDefinition::Variable*>(resource); 1357 std::ostringstream buf; 1358 std::ostringstream structureDescriptor; 1359 std::string uniformType; 1360 1361 for (const ResourceDefinition::Node* node = resource; node; node = node->getEnclosingNode()) 1362 { 1363 if (node->getType() == ResourceDefinition::Node::TYPE_STORAGE_QUALIFIER) 1364 { 1365 DE_ASSERT(dynamic_cast<const ResourceDefinition::StorageQualifier*>(node)); 1366 1367 const ResourceDefinition::StorageQualifier* storageDef = static_cast<const ResourceDefinition::StorageQualifier*>(node); 1368 1369 uniformType = std::string(" ") + glu::getStorageName(storageDef->m_storage); 1370 structureDescriptor << "\n\tdeclared as \"" << glu::getStorageName(storageDef->m_storage) << "\""; 1371 } 1372 1373 if (node->getType() == ResourceDefinition::Node::TYPE_ARRAY_ELEMENT) 1374 structureDescriptor << "\n\tarray"; 1375 1376 if (node->getType() == ResourceDefinition::Node::TYPE_STRUCT_MEMBER) 1377 structureDescriptor << "\n\tin a struct"; 1378 1379 if (node->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK) 1380 structureDescriptor << "\n\tin the default block"; 1381 1382 if (node->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK) 1383 structureDescriptor << "\n\tin an interface block"; 1384 } 1385 1386 buf << "Querying properties of " << glu::getDataTypeName(varDef->m_dataType) << uniformType << " variable.\n" 1387 << "Variable is:\n" 1388 << "\t" << glu::getDataTypeName(varDef->m_dataType) 1389 << structureDescriptor.str(); 1390 1391 return buf.str(); 1392 } 1393 else if (resource->getType() == ResourceDefinition::Node::TYPE_TRANSFORM_FEEDBACK_TARGET) 1394 { 1395 DE_ASSERT(dynamic_cast<const ResourceDefinition::TransformFeedbackTarget*>(resource)); 1396 1397 const ResourceDefinition::TransformFeedbackTarget* xfbDef = static_cast<const ResourceDefinition::TransformFeedbackTarget*>(resource); 1398 1399 DE_ASSERT(xfbDef->m_builtinVarName); 1400 1401 return std::string("Querying properties of a builtin variable ") + xfbDef->m_builtinVarName; 1402 } 1403 1404 DE_ASSERT(false); 1405 return DE_NULL; 1406 } 1407 1408 class ResourceNameBufferLimitCase : public TestCase 1409 { 1410 public: 1411 ResourceNameBufferLimitCase (Context& context, const char* name, const char* description); 1412 ~ResourceNameBufferLimitCase (void); 1413 1414 private: 1415 IterateResult iterate (void); 1416 }; 1417 1418 ResourceNameBufferLimitCase::ResourceNameBufferLimitCase (Context& context, const char* name, const char* description) 1419 : TestCase(context, name, description) 1420 { 1421 } 1422 1423 ResourceNameBufferLimitCase::~ResourceNameBufferLimitCase (void) 1424 { 1425 } 1426 1427 ResourceNameBufferLimitCase::IterateResult ResourceNameBufferLimitCase::iterate (void) 1428 { 1429 static const char* const computeSource = "#version 310 es\n" 1430 "layout(local_size_x = 1) in;\n" 1431 "uniform highp int u_uniformWithALongName;\n" 1432 "writeonly buffer OutputBufferBlock { highp int b_output_int; };\n" 1433 "void main ()\n" 1434 "{\n" 1435 " b_output_int = u_uniformWithALongName;\n" 1436 "}\n"; 1437 1438 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1439 const glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(computeSource)); 1440 glw::GLuint uniformIndex; 1441 1442 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1443 1444 // Log program 1445 { 1446 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Program", "Program"); 1447 1448 m_testCtx.getLog() << program; 1449 if (!program.isOk()) 1450 throw tcu::TestError("could not build program"); 1451 } 1452 1453 uniformIndex = gl.getProgramResourceIndex(program.getProgram(), GL_UNIFORM, "u_uniformWithALongName"); 1454 GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index"); 1455 1456 if (uniformIndex == GL_INVALID_INDEX) 1457 throw tcu::TestError("Uniform u_uniformWithALongName resource index was GL_INVALID_INDEX"); 1458 1459 // Query with different sized buffers, len("u_uniformWithALongName") == 22 1460 1461 { 1462 static const struct 1463 { 1464 const char* description; 1465 int querySize; 1466 bool returnLength; 1467 } querySizes[] = 1468 { 1469 { "Query to larger buffer", 24, true }, 1470 { "Query to buffer the same size", 23, true }, 1471 { "Query to one byte too small buffer", 22, true }, 1472 { "Query to one byte buffer", 1, true }, 1473 { "Query to zero sized buffer", 0, true }, 1474 { "Query to one byte too small buffer, null length argument", 22, false }, 1475 { "Query to one byte buffer, null length argument", 1, false }, 1476 { "Query to zero sized buffer, null length argument", 0, false }, 1477 }; 1478 1479 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(querySizes); ++ndx) 1480 { 1481 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Query", querySizes[ndx].description); 1482 const int uniformNameLen = 22; 1483 const int expectedWriteLen = (querySizes[ndx].querySize != 0) ? (de::min(uniformNameLen, (querySizes[ndx].querySize - 1))) : (0); 1484 char buffer [26]; 1485 glw::GLsizei written = -1; 1486 1487 // One byte for guard 1488 DE_ASSERT((int)sizeof(buffer) > querySizes[ndx].querySize); 1489 1490 deMemset(buffer, 'x', sizeof(buffer)); 1491 1492 if (querySizes[ndx].querySize) 1493 m_testCtx.getLog() 1494 << tcu::TestLog::Message 1495 << "Querying uniform name to a buffer of size " << querySizes[ndx].querySize 1496 << ", expecting query to write " << expectedWriteLen << " bytes followed by a null terminator" 1497 << tcu::TestLog::EndMessage; 1498 else 1499 m_testCtx.getLog() 1500 << tcu::TestLog::Message 1501 << "Querying uniform name to a buffer of size " << querySizes[ndx].querySize 1502 << ", expecting query to write 0 bytes" 1503 << tcu::TestLog::EndMessage; 1504 1505 gl.getProgramResourceName(program.getProgram(), GL_UNIFORM, uniformIndex, querySizes[ndx].querySize, (querySizes[ndx].returnLength) ? (&written) : (DE_NULL), buffer); 1506 GLU_EXPECT_NO_ERROR(gl.getError(), "query resource name"); 1507 1508 if (querySizes[ndx].returnLength && written != expectedWriteLen) 1509 { 1510 m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected write length of " << expectedWriteLen << ", got " << written << tcu::TestLog::EndMessage; 1511 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected write lenght"); 1512 } 1513 else if (querySizes[ndx].querySize != 0 && buffer[expectedWriteLen] != 0) 1514 { 1515 m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected null terminator at " << expectedWriteLen << ", got dec=" << (int)buffer[expectedWriteLen] << tcu::TestLog::EndMessage; 1516 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Missing null terminator"); 1517 } 1518 else if (querySizes[ndx].querySize != 0 && buffer[expectedWriteLen+1] != 'x') 1519 { 1520 m_testCtx.getLog() << tcu::TestLog::Message << "Error, guard at index " << (expectedWriteLen+1) << " was modified, got dec=" << (int)buffer[expectedWriteLen+1] << tcu::TestLog::EndMessage; 1521 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Wrote over buffer size"); 1522 } 1523 else if (querySizes[ndx].querySize == 0 && buffer[0] != 'x') 1524 { 1525 m_testCtx.getLog() << tcu::TestLog::Message << "Error, buffer size was 0 but buffer contents were modified. At index 0 got dec=" << (int)buffer[0] << tcu::TestLog::EndMessage; 1526 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer contents were modified"); 1527 } 1528 } 1529 } 1530 1531 return STOP; 1532 } 1533 1534 class ResourceQueryBufferLimitCase : public TestCase 1535 { 1536 public: 1537 ResourceQueryBufferLimitCase (Context& context, const char* name, const char* description); 1538 ~ResourceQueryBufferLimitCase (void); 1539 1540 private: 1541 IterateResult iterate (void); 1542 }; 1543 1544 ResourceQueryBufferLimitCase::ResourceQueryBufferLimitCase (Context& context, const char* name, const char* description) 1545 : TestCase(context, name, description) 1546 { 1547 } 1548 1549 ResourceQueryBufferLimitCase::~ResourceQueryBufferLimitCase (void) 1550 { 1551 } 1552 1553 ResourceQueryBufferLimitCase::IterateResult ResourceQueryBufferLimitCase::iterate (void) 1554 { 1555 static const char* const computeSource = "#version 310 es\n" 1556 "layout(local_size_x = 1) in;\n" 1557 "uniform highp int u_uniform;\n" 1558 "writeonly buffer OutputBufferBlock { highp int b_output_int; };\n" 1559 "void main ()\n" 1560 "{\n" 1561 " b_output_int = u_uniform;\n" 1562 "}\n"; 1563 1564 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1565 const glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(computeSource)); 1566 glw::GLuint uniformIndex; 1567 1568 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1569 1570 // Log program 1571 { 1572 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Program", "Program"); 1573 1574 m_testCtx.getLog() << program; 1575 if (!program.isOk()) 1576 throw tcu::TestError("could not build program"); 1577 } 1578 1579 uniformIndex = gl.getProgramResourceIndex(program.getProgram(), GL_UNIFORM, "u_uniform"); 1580 GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index"); 1581 1582 if (uniformIndex == GL_INVALID_INDEX) 1583 throw tcu::TestError("Uniform u_uniform resource index was GL_INVALID_INDEX"); 1584 1585 // Query uniform properties 1586 1587 { 1588 static const struct 1589 { 1590 const char* description; 1591 int numProps; 1592 int bufferSize; 1593 bool returnLength; 1594 } querySizes[] = 1595 { 1596 { "Query to a larger buffer", 2, 3, true }, 1597 { "Query to too small a buffer", 3, 2, true }, 1598 { "Query to zero sized buffer", 3, 0, true }, 1599 { "Query to a larger buffer, null length argument", 2, 3, false }, 1600 { "Query to too small a buffer, null length argument", 3, 2, false }, 1601 { "Query to zero sized buffer, null length argument", 3, 0, false }, 1602 }; 1603 1604 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(querySizes); ++ndx) 1605 { 1606 const tcu::ScopedLogSection section (m_testCtx.getLog(), "QueryToLarger", querySizes[ndx].description); 1607 const glw::GLenum props[] = { GL_LOCATION, GL_LOCATION, GL_LOCATION }; 1608 const int expectedWriteLen = de::min(querySizes[ndx].bufferSize, querySizes[ndx].numProps); 1609 int params[] = { 255, 255, 255, 255 }; 1610 glw::GLsizei written = -1; 1611 1612 DE_ASSERT(querySizes[ndx].numProps <= DE_LENGTH_OF_ARRAY(props)); 1613 DE_ASSERT(querySizes[ndx].bufferSize < DE_LENGTH_OF_ARRAY(params)); // leave at least one element for overflow detection 1614 1615 m_testCtx.getLog() 1616 << tcu::TestLog::Message 1617 << "Querying " << querySizes[ndx].numProps << " uniform prop(s) to a buffer with size " << querySizes[ndx].bufferSize << ". Expecting query to return " << expectedWriteLen << " prop(s)" 1618 << tcu::TestLog::EndMessage; 1619 1620 gl.getProgramResourceiv(program.getProgram(), GL_UNIFORM, uniformIndex, querySizes[ndx].numProps, props, querySizes[ndx].bufferSize, (querySizes[ndx].returnLength) ? (&written) : (DE_NULL), params); 1621 GLU_EXPECT_NO_ERROR(gl.getError(), "query program resources"); 1622 1623 if (querySizes[ndx].returnLength && written != expectedWriteLen) 1624 { 1625 m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected write length of " << expectedWriteLen << ", got " << written << tcu::TestLog::EndMessage; 1626 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected write lenght"); 1627 } 1628 else if (params[expectedWriteLen] != 255) 1629 { 1630 m_testCtx.getLog() << tcu::TestLog::Message << "Error, guard at index " << (expectedWriteLen) << " was modified. Was 255 before call, got dec=" << params[expectedWriteLen] << tcu::TestLog::EndMessage; 1631 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Wrote over buffer size"); 1632 } 1633 } 1634 } 1635 1636 return STOP; 1637 } 1638 1639 class InterfaceBlockBaseCase : public TestCase 1640 { 1641 public: 1642 enum CaseType 1643 { 1644 CASE_NAMED_BLOCK = 0, 1645 CASE_UNNAMED_BLOCK, 1646 CASE_BLOCK_ARRAY, 1647 1648 CASE_LAST 1649 }; 1650 1651 InterfaceBlockBaseCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType); 1652 ~InterfaceBlockBaseCase (void); 1653 1654 private: 1655 void init (void); 1656 void deinit (void); 1657 1658 protected: 1659 const glu::Storage m_storage; 1660 const CaseType m_caseType; 1661 ProgramInterfaceDefinition::Program* m_program; 1662 }; 1663 1664 InterfaceBlockBaseCase::InterfaceBlockBaseCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType) 1665 : TestCase (context, name, description) 1666 , m_storage (storage) 1667 , m_caseType (caseType) 1668 , m_program (DE_NULL) 1669 { 1670 DE_ASSERT(storage == glu::STORAGE_UNIFORM || storage == glu::STORAGE_BUFFER); 1671 } 1672 1673 InterfaceBlockBaseCase::~InterfaceBlockBaseCase (void) 1674 { 1675 deinit(); 1676 } 1677 1678 void InterfaceBlockBaseCase::init (void) 1679 { 1680 ProgramInterfaceDefinition::Shader* shader; 1681 1682 m_program = new ProgramInterfaceDefinition::Program(); 1683 shader = m_program->addShader(glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES); 1684 1685 // PrecedingInterface 1686 { 1687 glu::InterfaceBlock precedingInterfaceBlock; 1688 1689 precedingInterfaceBlock.interfaceName = "PrecedingInterface"; 1690 precedingInterfaceBlock.layout.binding = 0; 1691 precedingInterfaceBlock.storage = m_storage; 1692 precedingInterfaceBlock.instanceName = "precedingInstance"; 1693 1694 precedingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), "precedingMember")); 1695 1696 // Unsized array type 1697 if (m_storage == glu::STORAGE_BUFFER) 1698 precedingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY), "precedingMemberUnsizedArray")); 1699 else 1700 precedingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), 2), "precedingMemberArray")); 1701 1702 shader->getDefaultBlock().interfaceBlocks.push_back(precedingInterfaceBlock); 1703 } 1704 1705 // TargetInterface 1706 { 1707 glu::InterfaceBlock targetInterfaceBlock; 1708 1709 targetInterfaceBlock.interfaceName = "TargetInterface"; 1710 targetInterfaceBlock.layout.binding = 1; 1711 targetInterfaceBlock.storage = m_storage; 1712 1713 if (m_caseType == CASE_UNNAMED_BLOCK) 1714 targetInterfaceBlock.instanceName = ""; 1715 else 1716 targetInterfaceBlock.instanceName = "targetInstance"; 1717 1718 if (m_caseType == CASE_BLOCK_ARRAY) 1719 targetInterfaceBlock.dimensions.push_back(2); 1720 1721 // Basic type 1722 { 1723 targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), "blockMemberBasic")); 1724 } 1725 1726 // Array type 1727 { 1728 targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), 3), "blockMemberArray")); 1729 } 1730 1731 // Struct type 1732 { 1733 glu::StructType* structPtr = new glu::StructType("StructType"); 1734 structPtr->addMember("structMemberBasic", glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP)); 1735 structPtr->addMember("structMemberArray", glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), 2)); 1736 1737 targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(structPtr), 2), "blockMemberStruct")); 1738 } 1739 1740 // Unsized array type 1741 if (m_storage == glu::STORAGE_BUFFER) 1742 targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY), "blockMemberUnsizedArray")); 1743 1744 shader->getDefaultBlock().interfaceBlocks.push_back(targetInterfaceBlock); 1745 } 1746 1747 // TrailingInterface 1748 { 1749 glu::InterfaceBlock trailingInterfaceBlock; 1750 1751 trailingInterfaceBlock.interfaceName = "TrailingInterface"; 1752 trailingInterfaceBlock.layout.binding = 3; 1753 trailingInterfaceBlock.storage = m_storage; 1754 trailingInterfaceBlock.instanceName = "trailingInstance"; 1755 trailingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), "trailingMember")); 1756 1757 shader->getDefaultBlock().interfaceBlocks.push_back(trailingInterfaceBlock); 1758 } 1759 1760 DE_ASSERT(m_program->isValid()); 1761 } 1762 1763 void InterfaceBlockBaseCase::deinit (void) 1764 { 1765 delete m_program; 1766 m_program = DE_NULL; 1767 } 1768 1769 class InterfaceBlockActiveVariablesTestCase : public InterfaceBlockBaseCase 1770 { 1771 public: 1772 InterfaceBlockActiveVariablesTestCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType); 1773 1774 private: 1775 IterateResult iterate (void); 1776 }; 1777 1778 InterfaceBlockActiveVariablesTestCase::InterfaceBlockActiveVariablesTestCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType) 1779 : InterfaceBlockBaseCase(context, name, description, storage, caseType) 1780 { 1781 } 1782 1783 InterfaceBlockActiveVariablesTestCase::IterateResult InterfaceBlockActiveVariablesTestCase::iterate (void) 1784 { 1785 const ProgramInterface programInterface = (m_storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) : 1786 (m_storage == glu::STORAGE_BUFFER) ? (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK) : 1787 (PROGRAMINTERFACE_LAST); 1788 const glw::GLenum programGLInterfaceValue = getProgramInterfaceGLEnum(programInterface); 1789 const glw::GLenum programMemberInterfaceValue = (m_storage == glu::STORAGE_UNIFORM) ? (GL_UNIFORM) : 1790 (m_storage == glu::STORAGE_BUFFER) ? (GL_BUFFER_VARIABLE) : 1791 (0); 1792 const std::vector<std::string> blockNames = getProgramInterfaceResourceList(m_program, programInterface); 1793 glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program)); 1794 int expectedMaxNumActiveVariables = 0; 1795 1796 DE_ASSERT(programInterface != PROGRAMINTERFACE_LAST); 1797 1798 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1799 checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 1800 1801 // Verify all blocks 1802 1803 for (int blockNdx = 0; blockNdx < (int)blockNames.size(); ++blockNdx) 1804 { 1805 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Block", "Block \"" + blockNames[blockNdx] + "\""); 1806 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1807 const glw::GLuint resourceNdx = gl.getProgramResourceIndex(program.getProgram(), programGLInterfaceValue, blockNames[blockNdx].c_str()); 1808 glw::GLint numActiveResources; 1809 std::vector<std::string> activeResourceNames; 1810 1811 GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index"); 1812 1813 if (resourceNdx == GL_INVALID_INDEX) 1814 { 1815 m_testCtx.getLog() << tcu::TestLog::Message << "Error, getProgramResourceIndex returned GL_INVALID_INDEX for \"" << blockNames[blockNdx] << "\"" << tcu::TestLog::EndMessage; 1816 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Resource not found"); 1817 continue; 1818 } 1819 1820 // query block information 1821 1822 { 1823 const glw::GLenum props[] = { GL_NUM_ACTIVE_VARIABLES }; 1824 glw::GLint retBuffer[2] = { -1, -1 }; 1825 glw::GLint written = -1; 1826 1827 gl.getProgramResourceiv(program.getProgram(), programGLInterfaceValue, resourceNdx, DE_LENGTH_OF_ARRAY(props), props, 1, &written, retBuffer); 1828 GLU_EXPECT_NO_ERROR(gl.getError(), "query GL_NUM_ACTIVE_VARIABLES"); 1829 1830 numActiveResources = retBuffer[0]; 1831 expectedMaxNumActiveVariables = de::max(expectedMaxNumActiveVariables, numActiveResources); 1832 m_testCtx.getLog() << tcu::TestLog::Message << "NUM_ACTIVE_VARIABLES = " << numActiveResources << tcu::TestLog::EndMessage; 1833 1834 if (written == -1 || retBuffer[0] == -1) 1835 { 1836 m_testCtx.getLog() << tcu::TestLog::Message << "Error, Query for NUM_ACTIVE_VARIABLES did not return a value" << tcu::TestLog::EndMessage; 1837 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Query for NUM_ACTIVE_VARIABLES failed"); 1838 continue; 1839 } 1840 else if (retBuffer[1] != -1) 1841 { 1842 m_testCtx.getLog() << tcu::TestLog::Message << "Error, Query for NUM_ACTIVE_VARIABLES returned too many values" << tcu::TestLog::EndMessage; 1843 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Query for NUM_ACTIVE_VARIABLES returned too many values"); 1844 continue; 1845 } 1846 else if (retBuffer[0] < 0) 1847 { 1848 m_testCtx.getLog() << tcu::TestLog::Message << "Error, NUM_ACTIVE_VARIABLES < 0" << tcu::TestLog::EndMessage; 1849 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "NUM_ACTIVE_VARIABLES < 0"); 1850 continue; 1851 } 1852 } 1853 1854 // query block variable information 1855 1856 { 1857 const glw::GLenum props[] = { GL_ACTIVE_VARIABLES }; 1858 std::vector<glw::GLint> activeVariableIndices (numActiveResources + 1, -1); // Allocate one extra trailing to detect wrong write lengths 1859 glw::GLint written = -1; 1860 1861 gl.getProgramResourceiv(program.getProgram(), programGLInterfaceValue, resourceNdx, DE_LENGTH_OF_ARRAY(props), props, (glw::GLsizei)activeVariableIndices.size(), &written, &activeVariableIndices[0]); 1862 GLU_EXPECT_NO_ERROR(gl.getError(), "query GL_ACTIVE_VARIABLES"); 1863 1864 if (written == -1) 1865 { 1866 m_testCtx.getLog() << tcu::TestLog::Message << "Error, Query for GL_ACTIVE_VARIABLES did not return any values" << tcu::TestLog::EndMessage; 1867 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Query for GL_ACTIVE_VARIABLES failed"); 1868 continue; 1869 } 1870 else if (written != numActiveResources) 1871 { 1872 m_testCtx.getLog() << tcu::TestLog::Message << "Error, Query for GL_ACTIVE_VARIABLES did not return NUM_ACTIVE_VARIABLES values" << tcu::TestLog::EndMessage; 1873 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Query for GL_ACTIVE_VARIABLES returned invalid number of values"); 1874 continue; 1875 } 1876 else if (activeVariableIndices.back() != -1) 1877 { 1878 m_testCtx.getLog() << tcu::TestLog::Message << "Error, GL_ACTIVE_VARIABLES query return buffer trailing guard value was modified, getProgramResourceiv returned more than NUM_ACTIVE_VARIABLES values" << tcu::TestLog::EndMessage; 1879 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Query for GL_ACTIVE_VARIABLES returned too many values"); 1880 continue; 1881 } 1882 1883 // log indices 1884 { 1885 tcu::MessageBuilder builder(&m_testCtx.getLog()); 1886 1887 builder << "Active variable indices: {"; 1888 for (int varNdx = 0; varNdx < numActiveResources; ++varNdx) 1889 { 1890 if (varNdx) 1891 builder << ", "; 1892 builder << activeVariableIndices[varNdx]; 1893 } 1894 builder << "}" << tcu::TestLog::EndMessage; 1895 } 1896 1897 // collect names 1898 1899 activeResourceNames.resize(numActiveResources); 1900 1901 for (int varNdx = 0; varNdx < numActiveResources; ++varNdx) 1902 { 1903 const glw::GLenum nameProp = GL_NAME_LENGTH; 1904 glw::GLint nameLength = -1; 1905 std::vector<char> nameBuffer; 1906 1907 written = -1; 1908 gl.getProgramResourceiv(program.getProgram(), programMemberInterfaceValue, activeVariableIndices[varNdx], 1, &nameProp, 1, &written, &nameLength); 1909 GLU_EXPECT_NO_ERROR(gl.getError(), "query GL_NAME_LENGTH"); 1910 1911 if (nameLength <= 0 || written <= 0) 1912 { 1913 m_testCtx.getLog() << tcu::TestLog::Message << "Error, GL_NAME_LENGTH query failed" << tcu::TestLog::EndMessage; 1914 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "GL_NAME_LENGTH query failed"); 1915 continue; 1916 } 1917 1918 nameBuffer.resize(nameLength + 2, 'X'); // allocate more than required 1919 written = -1; 1920 gl.getProgramResourceName(program.getProgram(), programMemberInterfaceValue, activeVariableIndices[varNdx], nameLength+1, &written, &nameBuffer[0]); 1921 GLU_EXPECT_NO_ERROR(gl.getError(), "getProgramResourceName"); 1922 1923 if (written <= 0) 1924 { 1925 m_testCtx.getLog() << tcu::TestLog::Message << "Error, name query failed, no data written" << tcu::TestLog::EndMessage; 1926 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "name query failed"); 1927 continue; 1928 } 1929 else if (written > nameLength) 1930 { 1931 m_testCtx.getLog() << tcu::TestLog::Message << "Error, name query failed, query returned too much data" << tcu::TestLog::EndMessage; 1932 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "name query failed"); 1933 continue; 1934 } 1935 1936 activeResourceNames[varNdx] = std::string(&nameBuffer[0], written); 1937 } 1938 1939 // log collected names 1940 { 1941 tcu::MessageBuilder builder(&m_testCtx.getLog()); 1942 1943 builder << "Active variables:\n"; 1944 for (int varNdx = 0; varNdx < numActiveResources; ++varNdx) 1945 builder << "\t" << activeResourceNames[varNdx] << "\n"; 1946 builder << tcu::TestLog::EndMessage; 1947 } 1948 } 1949 1950 // verify names 1951 { 1952 glu::InterfaceBlock* block = DE_NULL; 1953 const std::string blockName = glu::parseVariableName(blockNames[blockNdx].c_str()); 1954 std::vector<std::string> referenceList; 1955 1956 for (int interfaceNdx = 0; interfaceNdx < (int)m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks.size(); ++interfaceNdx) 1957 { 1958 if (m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks[interfaceNdx].interfaceName == blockName) 1959 { 1960 block = &m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks[interfaceNdx]; 1961 break; 1962 } 1963 } 1964 1965 if (!block) 1966 throw tcu::InternalError("could not find block referenced in the reference resource list"); 1967 1968 // generate reference list 1969 1970 referenceList = getProgramInterfaceBlockMemberResourceList(*block); 1971 { 1972 tcu::MessageBuilder builder(&m_testCtx.getLog()); 1973 1974 builder << "Expected variable names:\n"; 1975 for (int varNdx = 0; varNdx < (int)referenceList.size(); ++varNdx) 1976 builder << "\t" << referenceList[varNdx] << "\n"; 1977 builder << tcu::TestLog::EndMessage; 1978 } 1979 1980 // compare lists 1981 { 1982 bool listsIdentical = true; 1983 1984 for (int ndx = 0; ndx < (int)referenceList.size(); ++ndx) 1985 { 1986 if (!de::contains(activeResourceNames.begin(), activeResourceNames.end(), referenceList[ndx])) 1987 { 1988 m_testCtx.getLog() << tcu::TestLog::Message << "Error, variable name list did not contain active variable " << referenceList[ndx] << tcu::TestLog::EndMessage; 1989 listsIdentical = false; 1990 } 1991 } 1992 1993 for (int ndx = 0; ndx < (int)activeResourceNames.size(); ++ndx) 1994 { 1995 if (!de::contains(referenceList.begin(), referenceList.end(), activeResourceNames[ndx])) 1996 { 1997 m_testCtx.getLog() << tcu::TestLog::Message << "Error, variable name list contains unexpected resource \"" << activeResourceNames[ndx] << "\"" << tcu::TestLog::EndMessage; 1998 listsIdentical = false; 1999 } 2000 } 2001 2002 if (listsIdentical) 2003 m_testCtx.getLog() << tcu::TestLog::Message << "Lists identical" << tcu::TestLog::EndMessage; 2004 else 2005 { 2006 m_testCtx.getLog() << tcu::TestLog::Message << "Error, invalid active variable list" << tcu::TestLog::EndMessage; 2007 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid active variable list"); 2008 continue; 2009 } 2010 } 2011 } 2012 } 2013 2014 // Max num active variables 2015 { 2016 const tcu::ScopedLogSection section (m_testCtx.getLog(), "MaxNumActiveVariables", "MAX_NUM_ACTIVE_VARIABLES"); 2017 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2018 glw::GLint maxNumActiveVariables = -1; 2019 2020 gl.getProgramInterfaceiv(program.getProgram(), programGLInterfaceValue, GL_MAX_NUM_ACTIVE_VARIABLES, &maxNumActiveVariables); 2021 GLU_EXPECT_NO_ERROR(gl.getError(), "query MAX_NUM_ACTIVE_VARIABLES"); 2022 2023 m_testCtx.getLog() << tcu::TestLog::Message << "MAX_NUM_ACTIVE_VARIABLES = " << maxNumActiveVariables << tcu::TestLog::EndMessage; 2024 2025 if (expectedMaxNumActiveVariables != maxNumActiveVariables) 2026 { 2027 m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected MAX_NUM_ACTIVE_VARIABLES" << tcu::TestLog::EndMessage; 2028 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "unexpected MAX_NUM_ACTIVE_VARIABLES"); 2029 } 2030 else 2031 m_testCtx.getLog() << tcu::TestLog::Message << "MAX_NUM_ACTIVE_VARIABLES valid" << tcu::TestLog::EndMessage; 2032 } 2033 2034 return STOP; 2035 } 2036 2037 class InterfaceBlockDataSizeTestCase : public InterfaceBlockBaseCase 2038 { 2039 public: 2040 InterfaceBlockDataSizeTestCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType); 2041 2042 private: 2043 IterateResult iterate (void); 2044 int getBlockMinDataSize (const std::string& blockName) const; 2045 int getBlockMinDataSize (const glu::InterfaceBlock& block) const; 2046 }; 2047 2048 InterfaceBlockDataSizeTestCase::InterfaceBlockDataSizeTestCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType) 2049 : InterfaceBlockBaseCase(context, name, description, storage, caseType) 2050 { 2051 } 2052 2053 InterfaceBlockDataSizeTestCase::IterateResult InterfaceBlockDataSizeTestCase::iterate (void) 2054 { 2055 const ProgramInterface programInterface = (m_storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) : 2056 (m_storage == glu::STORAGE_BUFFER) ? (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK) : 2057 (PROGRAMINTERFACE_LAST); 2058 const glw::GLenum programGLInterfaceValue = getProgramInterfaceGLEnum(programInterface); 2059 const std::vector<std::string> blockNames = getProgramInterfaceResourceList(m_program, programInterface); 2060 glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program)); 2061 2062 DE_ASSERT(programInterface != PROGRAMINTERFACE_LAST); 2063 2064 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2065 checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 2066 2067 // Verify all blocks 2068 for (int blockNdx = 0; blockNdx < (int)blockNames.size(); ++blockNdx) 2069 { 2070 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Block", "Block \"" + blockNames[blockNdx] + "\""); 2071 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2072 const glw::GLuint resourceNdx = gl.getProgramResourceIndex(program.getProgram(), programGLInterfaceValue, blockNames[blockNdx].c_str()); 2073 const int expectedMinDataSize = getBlockMinDataSize(blockNames[blockNdx]); 2074 glw::GLint queryDataSize = -1; 2075 2076 GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index"); 2077 2078 if (resourceNdx == GL_INVALID_INDEX) 2079 { 2080 m_testCtx.getLog() << tcu::TestLog::Message << "Error, getProgramResourceIndex returned GL_INVALID_INDEX for \"" << blockNames[blockNdx] << "\"" << tcu::TestLog::EndMessage; 2081 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Resource not found"); 2082 continue; 2083 } 2084 2085 // query 2086 { 2087 const glw::GLenum prop = GL_BUFFER_DATA_SIZE; 2088 2089 gl.getProgramResourceiv(program.getProgram(), programGLInterfaceValue, resourceNdx, 1, &prop, 1, DE_NULL, &queryDataSize); 2090 GLU_EXPECT_NO_ERROR(gl.getError(), "query resource BUFFER_DATA_SIZE"); 2091 } 2092 2093 m_testCtx.getLog() 2094 << tcu::TestLog::Message 2095 << "BUFFER_DATA_SIZE = " << queryDataSize << "\n" 2096 << "Buffer data size with tight packing: " << expectedMinDataSize 2097 << tcu::TestLog::EndMessage; 2098 2099 if (queryDataSize < expectedMinDataSize) 2100 { 2101 m_testCtx.getLog() << tcu::TestLog::Message << "Error, buffer size was less than minimum buffer data size" << tcu::TestLog::EndMessage; 2102 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer data size invalid"); 2103 continue; 2104 } 2105 else 2106 m_testCtx.getLog() << tcu::TestLog::Message << "Buffer size valid" << tcu::TestLog::EndMessage; 2107 } 2108 2109 return STOP; 2110 } 2111 2112 int InterfaceBlockDataSizeTestCase::getBlockMinDataSize (const std::string& blockFullName) const 2113 { 2114 const std::string blockName = glu::parseVariableName(blockFullName.c_str()); 2115 2116 for (int interfaceNdx = 0; interfaceNdx < (int)m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks.size(); ++interfaceNdx) 2117 { 2118 if (m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks[interfaceNdx].interfaceName == blockName && 2119 m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks[interfaceNdx].storage == m_storage) 2120 return getBlockMinDataSize(m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks[interfaceNdx]); 2121 } 2122 2123 DE_ASSERT(false); 2124 return -1; 2125 } 2126 2127 class AtomicCounterCase : public TestCase 2128 { 2129 public: 2130 AtomicCounterCase (Context& context, const char* name, const char* description); 2131 ~AtomicCounterCase (void); 2132 2133 private: 2134 void init (void); 2135 void deinit (void); 2136 2137 protected: 2138 int getNumAtomicCounterBuffers (void) const; 2139 int getMaxNumActiveVariables (void) const; 2140 int getBufferVariableCount (int binding) const; 2141 int getBufferMinimumDataSize (int binding) const; 2142 2143 ProgramInterfaceDefinition::Program* m_program; 2144 }; 2145 2146 AtomicCounterCase::AtomicCounterCase (Context& context, const char* name, const char* description) 2147 : TestCase (context, name, description) 2148 , m_program (DE_NULL) 2149 { 2150 } 2151 2152 AtomicCounterCase::~AtomicCounterCase (void) 2153 { 2154 deinit(); 2155 } 2156 2157 void AtomicCounterCase::init (void) 2158 { 2159 ProgramInterfaceDefinition::Shader* shader; 2160 2161 m_program = new ProgramInterfaceDefinition::Program(); 2162 shader = m_program->addShader(glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES); 2163 2164 { 2165 glu::VariableDeclaration decl(glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "binding1_counter1", glu::STORAGE_UNIFORM); 2166 decl.layout.binding = 1; 2167 shader->getDefaultBlock().variables.push_back(decl); 2168 } 2169 { 2170 glu::VariableDeclaration decl(glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "binding1_counter2", glu::STORAGE_UNIFORM); 2171 decl.layout.binding = 1; 2172 decl.layout.offset = 8; 2173 2174 shader->getDefaultBlock().variables.push_back(decl); 2175 } 2176 { 2177 glu::VariableDeclaration decl(glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "binding2_counter1", glu::STORAGE_UNIFORM); 2178 decl.layout.binding = 2; 2179 shader->getDefaultBlock().variables.push_back(decl); 2180 } 2181 2182 DE_ASSERT(m_program->isValid()); 2183 } 2184 2185 void AtomicCounterCase::deinit (void) 2186 { 2187 delete m_program; 2188 m_program = DE_NULL; 2189 } 2190 2191 int AtomicCounterCase::getNumAtomicCounterBuffers (void) const 2192 { 2193 std::set<int> buffers; 2194 2195 for (int ndx = 0; ndx < (int)m_program->getShaders()[0]->getDefaultBlock().variables.size(); ++ndx) 2196 { 2197 if (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.isBasicType() && 2198 glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType())) 2199 { 2200 buffers.insert(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.binding); 2201 } 2202 } 2203 2204 return (int)buffers.size(); 2205 } 2206 2207 int AtomicCounterCase::getMaxNumActiveVariables (void) const 2208 { 2209 int maxVars = 0; 2210 std::map<int,int> numBufferVars; 2211 2212 for (int ndx = 0; ndx < (int)m_program->getShaders()[0]->getDefaultBlock().variables.size(); ++ndx) 2213 { 2214 if (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.isBasicType() && 2215 glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType())) 2216 { 2217 const int binding = m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.binding; 2218 2219 if (numBufferVars.find(binding) == numBufferVars.end()) 2220 numBufferVars[binding] = 1; 2221 else 2222 ++numBufferVars[binding]; 2223 } 2224 } 2225 2226 for (std::map<int,int>::const_iterator it = numBufferVars.begin(); it != numBufferVars.end(); ++it) 2227 maxVars = de::max(maxVars, it->second); 2228 2229 return maxVars; 2230 } 2231 2232 int AtomicCounterCase::getBufferVariableCount (int binding) const 2233 { 2234 int numVars = 0; 2235 2236 for (int ndx = 0; ndx < (int)m_program->getShaders()[0]->getDefaultBlock().variables.size(); ++ndx) 2237 { 2238 if (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.isBasicType() && 2239 glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType()) && 2240 m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.binding == binding) 2241 ++numVars; 2242 } 2243 2244 return numVars; 2245 } 2246 2247 int AtomicCounterCase::getBufferMinimumDataSize (int binding) const 2248 { 2249 int minSize = -1; 2250 int currentOffset = 0; 2251 2252 for (int ndx = 0; ndx < (int)m_program->getShaders()[0]->getDefaultBlock().variables.size(); ++ndx) 2253 { 2254 if (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.isBasicType() && 2255 glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType()) && 2256 m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.binding == binding) 2257 { 2258 const int thisOffset = (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.offset != -1) ? (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.offset) : (currentOffset); 2259 currentOffset = thisOffset + 4; 2260 2261 minSize = de::max(minSize, thisOffset + 4); 2262 } 2263 } 2264 2265 return minSize; 2266 } 2267 2268 class AtomicCounterResourceListCase : public AtomicCounterCase 2269 { 2270 public: 2271 AtomicCounterResourceListCase (Context& context, const char* name, const char* description); 2272 2273 private: 2274 IterateResult iterate (void); 2275 }; 2276 2277 AtomicCounterResourceListCase::AtomicCounterResourceListCase (Context& context, const char* name, const char* description) 2278 : AtomicCounterCase(context, name, description) 2279 { 2280 } 2281 2282 AtomicCounterResourceListCase::IterateResult AtomicCounterResourceListCase::iterate (void) 2283 { 2284 const glu::ShaderProgram program(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program)); 2285 2286 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2287 checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 2288 2289 { 2290 const tcu::ScopedLogSection section (m_testCtx.getLog(), "ActiveResources", "ACTIVE_RESOURCES"); 2291 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2292 glw::GLint numActiveResources = -1; 2293 const int numExpectedActiveResources = 2; // 2 buffer bindings 2294 2295 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying ACTIVE_RESOURCES, expecting " << numExpectedActiveResources << tcu::TestLog::EndMessage; 2296 2297 gl.getProgramInterfaceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, GL_ACTIVE_RESOURCES, &numActiveResources); 2298 GLU_EXPECT_NO_ERROR(gl.getError(), "query GL_ACTIVE_RESOURCES"); 2299 2300 m_testCtx.getLog() << tcu::TestLog::Message << "ACTIVE_RESOURCES = " << numActiveResources << tcu::TestLog::EndMessage; 2301 2302 if (numActiveResources != numExpectedActiveResources) 2303 { 2304 m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected ACTIVE_RESOURCES" << tcu::TestLog::EndMessage; 2305 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected ACTIVE_RESOURCES"); 2306 } 2307 else 2308 m_testCtx.getLog() << tcu::TestLog::Message << "ACTIVE_RESOURCES valid" << tcu::TestLog::EndMessage; 2309 } 2310 2311 return STOP; 2312 } 2313 2314 class AtomicCounterActiveVariablesCase : public AtomicCounterCase 2315 { 2316 public: 2317 AtomicCounterActiveVariablesCase (Context& context, const char* name, const char* description); 2318 2319 private: 2320 IterateResult iterate (void); 2321 }; 2322 2323 AtomicCounterActiveVariablesCase::AtomicCounterActiveVariablesCase (Context& context, const char* name, const char* description) 2324 : AtomicCounterCase(context, name, description) 2325 { 2326 } 2327 2328 AtomicCounterActiveVariablesCase::IterateResult AtomicCounterActiveVariablesCase::iterate (void) 2329 { 2330 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2331 const glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program)); 2332 const int numAtomicBuffers = getNumAtomicCounterBuffers(); 2333 const int expectedMaxNumActiveVariables = getMaxNumActiveVariables(); 2334 2335 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2336 checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 2337 2338 // check active variables 2339 { 2340 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Interface", "ATOMIC_COUNTER_BUFFER interface"); 2341 glw::GLint queryActiveResources = -1; 2342 glw::GLint queryMaxNumActiveVariables = -1; 2343 2344 gl.getProgramInterfaceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, GL_ACTIVE_RESOURCES, &queryActiveResources); 2345 gl.getProgramInterfaceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, GL_MAX_NUM_ACTIVE_VARIABLES, &queryMaxNumActiveVariables); 2346 GLU_EXPECT_NO_ERROR(gl.getError(), "query interface"); 2347 2348 m_testCtx.getLog() 2349 << tcu::TestLog::Message 2350 << "GL_ACTIVE_RESOURCES = " << queryActiveResources << "\n" 2351 << "GL_MAX_NUM_ACTIVE_VARIABLES = " << queryMaxNumActiveVariables << "\n" 2352 << tcu::TestLog::EndMessage; 2353 2354 if (queryActiveResources != numAtomicBuffers) 2355 { 2356 m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected GL_ACTIVE_RESOURCES, expected " << numAtomicBuffers << tcu::TestLog::EndMessage; 2357 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected GL_ACTIVE_RESOURCES"); 2358 } 2359 2360 if (queryMaxNumActiveVariables != expectedMaxNumActiveVariables) 2361 { 2362 m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected GL_MAX_NUM_ACTIVE_VARIABLES, expected " << expectedMaxNumActiveVariables << tcu::TestLog::EndMessage; 2363 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected GL_MAX_NUM_ACTIVE_VARIABLES"); 2364 } 2365 } 2366 2367 // Check each buffer 2368 for (int bufferNdx = 0; bufferNdx < numAtomicBuffers; ++bufferNdx) 2369 { 2370 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Resource", "Resource index " + de::toString(bufferNdx)); 2371 std::vector<glw::GLint> activeVariables; 2372 std::vector<std::string> memberNames; 2373 2374 // Find active variables 2375 { 2376 const glw::GLenum numActiveVariablesProp = GL_NUM_ACTIVE_VARIABLES; 2377 const glw::GLenum activeVariablesProp = GL_ACTIVE_VARIABLES; 2378 glw::GLint numActiveVariables = -2; 2379 glw::GLint written = -1; 2380 2381 gl.getProgramResourceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, bufferNdx, 1, &numActiveVariablesProp, 1, &written, &numActiveVariables); 2382 GLU_EXPECT_NO_ERROR(gl.getError(), "query num active variables"); 2383 2384 if (numActiveVariables <= 0) 2385 { 2386 m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected NUM_ACTIVE_VARIABLES: " << numActiveVariables << tcu::TestLog::EndMessage; 2387 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected NUM_ACTIVE_VARIABLES"); 2388 continue; 2389 } 2390 2391 if (written <= 0) 2392 { 2393 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for NUM_ACTIVE_VARIABLES returned no values" << tcu::TestLog::EndMessage; 2394 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "NUM_ACTIVE_VARIABLES query failed"); 2395 continue; 2396 } 2397 2398 m_testCtx.getLog() << tcu::TestLog::Message << "GL_NUM_ACTIVE_VARIABLES = " << numActiveVariables << tcu::TestLog::EndMessage; 2399 2400 written = -1; 2401 activeVariables.resize(numActiveVariables + 1, -2); 2402 2403 gl.getProgramResourceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, bufferNdx, 1, &activeVariablesProp, numActiveVariables, &written, &activeVariables[0]); 2404 GLU_EXPECT_NO_ERROR(gl.getError(), "query active variables"); 2405 2406 if (written != numActiveVariables) 2407 { 2408 m_testCtx.getLog() << tcu::TestLog::Message << "Error, unexpected number of ACTIVE_VARIABLES, NUM_ACTIVE_VARIABLES = " << numActiveVariables << ", query returned " << written << " values" << tcu::TestLog::EndMessage; 2409 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected ACTIVE_VARIABLES"); 2410 continue; 2411 } 2412 2413 if (activeVariables.back() != -2) 2414 { 2415 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for ACTIVE_VARIABLES wrote over target buffer bounds" << tcu::TestLog::EndMessage; 2416 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "ACTIVE_VARIABLES query failed"); 2417 continue; 2418 } 2419 2420 activeVariables.pop_back(); 2421 } 2422 2423 // log indices 2424 { 2425 tcu::MessageBuilder builder(&m_testCtx.getLog()); 2426 2427 builder << "Active variable indices: {"; 2428 for (int varNdx = 0; varNdx < (int)activeVariables.size(); ++varNdx) 2429 { 2430 if (varNdx) 2431 builder << ", "; 2432 builder << activeVariables[varNdx]; 2433 } 2434 builder << "}" << tcu::TestLog::EndMessage; 2435 } 2436 2437 // collect member names 2438 for (int ndx = 0; ndx < (int)activeVariables.size(); ++ndx) 2439 { 2440 const glw::GLenum nameLengthProp = GL_NAME_LENGTH; 2441 glw::GLint nameLength = -1; 2442 glw::GLint written = -1; 2443 std::vector<char> nameBuf; 2444 2445 gl.getProgramResourceiv(program.getProgram(), GL_UNIFORM, activeVariables[ndx], 1, &nameLengthProp, 1, &written, &nameLength); 2446 GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer variable name length"); 2447 2448 if (written <= 0 || nameLength == -1) 2449 { 2450 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for GL_NAME_LENGTH returned no values" << tcu::TestLog::EndMessage; 2451 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "GL_NAME_LENGTH query failed"); 2452 continue; 2453 } 2454 2455 nameBuf.resize(nameLength + 2, 'X'); // +2 to tolerate potential off-by-ones in some implementations, name queries will check these cases better 2456 written = -1; 2457 2458 gl.getProgramResourceName(program.getProgram(), GL_UNIFORM, activeVariables[ndx], (int)nameBuf.size(), &written, &nameBuf[0]); 2459 GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer variable name"); 2460 2461 if (written <= 0) 2462 { 2463 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for resource name returned no name" << tcu::TestLog::EndMessage; 2464 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Name query failed"); 2465 continue; 2466 } 2467 2468 memberNames.push_back(std::string(&nameBuf[0], written)); 2469 } 2470 2471 // log names 2472 { 2473 tcu::MessageBuilder builder(&m_testCtx.getLog()); 2474 2475 builder << "Active variables:\n"; 2476 for (int varNdx = 0; varNdx < (int)memberNames.size(); ++varNdx) 2477 { 2478 builder << "\t" << memberNames[varNdx] << "\n"; 2479 } 2480 builder << tcu::TestLog::EndMessage; 2481 } 2482 2483 // check names are all in the same buffer 2484 { 2485 bool bindingsValid = true; 2486 2487 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying names" << tcu::TestLog::EndMessage; 2488 2489 for (int nameNdx = 0; nameNdx < (int)memberNames.size(); ++nameNdx) 2490 { 2491 int prevBinding = -1; 2492 2493 for (int varNdx = 0; varNdx < (int)m_program->getShaders()[0]->getDefaultBlock().variables.size(); ++varNdx) 2494 { 2495 if (m_program->getShaders()[0]->getDefaultBlock().variables[varNdx].name == memberNames[nameNdx]) 2496 { 2497 const int varBinding = m_program->getShaders()[0]->getDefaultBlock().variables[varNdx].layout.binding; 2498 2499 if (prevBinding == -1 || prevBinding == varBinding) 2500 prevBinding = varBinding; 2501 else 2502 bindingsValid = false; 2503 } 2504 } 2505 2506 if (prevBinding == -1) 2507 { 2508 m_testCtx.getLog() << tcu::TestLog::Message << "Error, could not find variable with name \"" << memberNames[nameNdx] << "\"" << tcu::TestLog::EndMessage; 2509 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Variable name invalid"); 2510 } 2511 else if (getBufferVariableCount(prevBinding) != (int)memberNames.size()) 2512 { 2513 m_testCtx.getLog() 2514 << tcu::TestLog::Message 2515 << "Error, unexpected variable count for binding " << prevBinding 2516 << ". Expected " << getBufferVariableCount(prevBinding) << ", got " << (int)memberNames.size() 2517 << tcu::TestLog::EndMessage; 2518 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Variable names invalid"); 2519 } 2520 } 2521 2522 if (!bindingsValid) 2523 { 2524 m_testCtx.getLog() << tcu::TestLog::Message << "Error, all resource do not share the same buffer" << tcu::TestLog::EndMessage; 2525 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Active variables invalid"); 2526 continue; 2527 } 2528 } 2529 } 2530 2531 return STOP; 2532 } 2533 2534 class AtomicCounterBufferBindingCase : public AtomicCounterCase 2535 { 2536 public: 2537 AtomicCounterBufferBindingCase (Context& context, const char* name, const char* description); 2538 2539 private: 2540 IterateResult iterate (void); 2541 }; 2542 2543 AtomicCounterBufferBindingCase::AtomicCounterBufferBindingCase (Context& context, const char* name, const char* description) 2544 : AtomicCounterCase(context, name, description) 2545 { 2546 } 2547 2548 AtomicCounterBufferBindingCase::IterateResult AtomicCounterBufferBindingCase::iterate (void) 2549 { 2550 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2551 const glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program)); 2552 const int numAtomicBuffers = getNumAtomicCounterBuffers(); 2553 2554 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2555 checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 2556 2557 // check every buffer 2558 for (int bufferNdx = 0; bufferNdx < numAtomicBuffers; ++bufferNdx) 2559 { 2560 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Resource", "Resource index " + de::toString(bufferNdx)); 2561 const glw::GLenum bufferBindingProp = GL_BUFFER_BINDING; 2562 glw::GLint bufferBinding = -1; 2563 glw::GLint written = -1; 2564 2565 gl.getProgramResourceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, bufferNdx, 1, &bufferBindingProp, 1, &written, &bufferBinding); 2566 GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer binding"); 2567 2568 if (written <= 0) 2569 { 2570 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for BUFFER_BINDING returned no values." << tcu::TestLog::EndMessage; 2571 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "BUFFER_BINDING query failed"); 2572 } 2573 2574 m_testCtx.getLog() << tcu::TestLog::Message << "GL_BUFFER_BINDING = " << bufferBinding << tcu::TestLog::EndMessage; 2575 2576 // no such buffer binding? 2577 if (getBufferVariableCount(bufferBinding) == 0) 2578 { 2579 m_testCtx.getLog() << tcu::TestLog::Message << "Error, got buffer with BUFFER_BINDING = " << bufferBinding << ", but such buffer does not exist." << tcu::TestLog::EndMessage; 2580 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected BUFFER_BINDING"); 2581 } 2582 } 2583 2584 return STOP; 2585 } 2586 2587 class AtomicCounterBufferDataSizeCase : public AtomicCounterCase 2588 { 2589 public: 2590 AtomicCounterBufferDataSizeCase (Context& context, const char* name, const char* description); 2591 2592 private: 2593 IterateResult iterate (void); 2594 }; 2595 2596 AtomicCounterBufferDataSizeCase::AtomicCounterBufferDataSizeCase (Context& context, const char* name, const char* description) 2597 : AtomicCounterCase(context, name, description) 2598 { 2599 } 2600 2601 AtomicCounterBufferDataSizeCase::IterateResult AtomicCounterBufferDataSizeCase::iterate (void) 2602 { 2603 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2604 const glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program)); 2605 const int numAtomicBuffers = getNumAtomicCounterBuffers(); 2606 2607 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2608 checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 2609 2610 // check every buffer 2611 for (int bufferNdx = 0; bufferNdx < numAtomicBuffers; ++bufferNdx) 2612 { 2613 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Resource", "Resource index " + de::toString(bufferNdx)); 2614 const glw::GLenum props[] = { GL_BUFFER_BINDING, GL_BUFFER_DATA_SIZE }; 2615 glw::GLint values[] = { -1, -1 }; 2616 glw::GLint written = -1; 2617 int bufferMinDataSize; 2618 2619 gl.getProgramResourceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, bufferNdx, DE_LENGTH_OF_ARRAY(props), props, DE_LENGTH_OF_ARRAY(values), &written, values); 2620 GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer binding"); 2621 2622 if (written != 2) 2623 { 2624 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for (BUFFER_BINDING, BUFFER_DATA_SIZE) returned " << written << " value(s)." << tcu::TestLog::EndMessage; 2625 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "property query failed"); 2626 continue; 2627 } 2628 2629 m_testCtx.getLog() 2630 << tcu::TestLog::Message 2631 << "GL_BUFFER_BINDING = " << values[0] << "\n" 2632 << "GL_BUFFER_DATA_SIZE = " << values[1] 2633 << tcu::TestLog::EndMessage; 2634 2635 bufferMinDataSize = getBufferMinimumDataSize(values[0]); 2636 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying data size, expected greater than or equal to " << bufferMinDataSize << tcu::TestLog::EndMessage; 2637 2638 // no such buffer binding? 2639 if (bufferMinDataSize == -1) 2640 { 2641 m_testCtx.getLog() << tcu::TestLog::Message << "Error, got buffer with BUFFER_BINDING = " << values[0] << ", but such buffer does not exist." << tcu::TestLog::EndMessage; 2642 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected BUFFER_BINDING"); 2643 } 2644 else if (values[1] < bufferMinDataSize) 2645 { 2646 m_testCtx.getLog() << tcu::TestLog::Message << "Error, got buffer with BUFFER_DATA_SIZE = " << values[1] << ", expected greater than or equal to " << bufferMinDataSize << tcu::TestLog::EndMessage; 2647 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected BUFFER_BINDING"); 2648 } 2649 else 2650 m_testCtx.getLog() << tcu::TestLog::Message << "Data size valid" << tcu::TestLog::EndMessage; 2651 } 2652 2653 return STOP; 2654 } 2655 2656 class AtomicCounterReferencedByCase : public TestCase 2657 { 2658 public: 2659 AtomicCounterReferencedByCase (Context& context, 2660 const char* name, 2661 const char* description, 2662 bool separable, 2663 deUint32 presentStagesMask, 2664 deUint32 activeStagesMask); 2665 ~AtomicCounterReferencedByCase (void); 2666 2667 private: 2668 void init (void); 2669 void deinit (void); 2670 IterateResult iterate (void); 2671 2672 const bool m_separable; 2673 const deUint32 m_presentStagesMask; 2674 const deUint32 m_activeStagesMask; 2675 ProgramInterfaceDefinition::Program* m_program; 2676 }; 2677 2678 AtomicCounterReferencedByCase::AtomicCounterReferencedByCase (Context& context, 2679 const char* name, 2680 const char* description, 2681 bool separable, 2682 deUint32 presentStagesMask, 2683 deUint32 activeStagesMask) 2684 : TestCase (context, name, description) 2685 , m_separable (separable) 2686 , m_presentStagesMask (presentStagesMask) 2687 , m_activeStagesMask (activeStagesMask) 2688 , m_program (DE_NULL) 2689 { 2690 DE_ASSERT((activeStagesMask & presentStagesMask) == activeStagesMask); 2691 } 2692 2693 AtomicCounterReferencedByCase::~AtomicCounterReferencedByCase (void) 2694 { 2695 deinit(); 2696 } 2697 2698 void AtomicCounterReferencedByCase::init (void) 2699 { 2700 const deUint32 geometryMask = (1 << glu::SHADERTYPE_GEOMETRY); 2701 const deUint32 tessellationMask = (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION); 2702 glu::VariableDeclaration atomicVar (glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "targetCounter", glu::STORAGE_UNIFORM); 2703 2704 if ((m_presentStagesMask & tessellationMask) != 0 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader")) 2705 throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader extension"); 2706 if ((m_presentStagesMask & geometryMask) != 0 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) 2707 throw tcu::NotSupportedError("Test requires GL_EXT_geometry_shader extension"); 2708 2709 atomicVar.layout.binding = 1; 2710 2711 m_program = new ProgramInterfaceDefinition::Program(); 2712 m_program->setSeparable(m_separable); 2713 2714 for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; ++shaderType) 2715 { 2716 if (m_activeStagesMask & (1 << shaderType)) 2717 m_program->addShader((glu::ShaderType)shaderType, glu::GLSL_VERSION_310_ES)->getDefaultBlock().variables.push_back(atomicVar); 2718 else if (m_presentStagesMask & (1 << shaderType)) 2719 m_program->addShader((glu::ShaderType)shaderType, glu::GLSL_VERSION_310_ES); 2720 } 2721 2722 if (m_program->hasStage(glu::SHADERTYPE_GEOMETRY)) 2723 m_program->setGeometryNumOutputVertices(1); 2724 if (m_program->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || m_program->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION)) 2725 m_program->setTessellationNumOutputPatchVertices(1); 2726 2727 DE_ASSERT(m_program->isValid()); 2728 } 2729 2730 void AtomicCounterReferencedByCase::deinit (void) 2731 { 2732 delete m_program; 2733 m_program = DE_NULL; 2734 } 2735 2736 AtomicCounterReferencedByCase::IterateResult AtomicCounterReferencedByCase::iterate (void) 2737 { 2738 static const struct 2739 { 2740 glw::GLenum propName; 2741 glu::ShaderType shaderType; 2742 const char* extension; 2743 } targetProps[] = 2744 { 2745 { GL_REFERENCED_BY_VERTEX_SHADER, glu::SHADERTYPE_VERTEX, DE_NULL }, 2746 { GL_REFERENCED_BY_FRAGMENT_SHADER, glu::SHADERTYPE_FRAGMENT, DE_NULL }, 2747 { GL_REFERENCED_BY_COMPUTE_SHADER, glu::SHADERTYPE_COMPUTE, DE_NULL }, 2748 { GL_REFERENCED_BY_TESS_CONTROL_SHADER, glu::SHADERTYPE_TESSELLATION_CONTROL, "GL_EXT_tessellation_shader" }, 2749 { GL_REFERENCED_BY_TESS_EVALUATION_SHADER, glu::SHADERTYPE_TESSELLATION_EVALUATION, "GL_EXT_tessellation_shader" }, 2750 { GL_REFERENCED_BY_GEOMETRY_SHADER, glu::SHADERTYPE_GEOMETRY, "GL_EXT_geometry_shader" }, 2751 }; 2752 2753 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2754 const glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program)); 2755 2756 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2757 checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 2758 2759 // check props 2760 for (int propNdx = 0; propNdx < DE_LENGTH_OF_ARRAY(targetProps); ++propNdx) 2761 { 2762 if (targetProps[propNdx].extension == DE_NULL || m_context.getContextInfo().isExtensionSupported(targetProps[propNdx].extension)) 2763 { 2764 const glw::GLenum prop = targetProps[propNdx].propName; 2765 const glw::GLint expected = ((m_activeStagesMask & (1 << targetProps[propNdx].shaderType)) != 0) ? (GL_TRUE) : (GL_FALSE); 2766 glw::GLint value = -1; 2767 glw::GLint written = -1; 2768 2769 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying " << glu::getProgramResourcePropertyName(prop) << ", expecting " << glu::getBooleanName(expected) << tcu::TestLog::EndMessage; 2770 2771 gl.getProgramResourceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, 0, 1, &prop, 1, &written, &value); 2772 GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer binding"); 2773 2774 if (written != 1) 2775 { 2776 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for referenced_by_* returned invalid number of values." << tcu::TestLog::EndMessage; 2777 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "property query failed"); 2778 continue; 2779 } 2780 2781 m_testCtx.getLog() << tcu::TestLog::Message << glu::getProgramResourcePropertyName(prop) << " = " << glu::getBooleanStr(value) << tcu::TestLog::EndMessage; 2782 2783 if (value != expected) 2784 { 2785 m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected value" << tcu::TestLog::EndMessage; 2786 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "unexpected property value"); 2787 continue; 2788 } 2789 } 2790 } 2791 2792 return STOP; 2793 } 2794 2795 class ProgramInputOutputReferencedByCase : public TestCase 2796 { 2797 public: 2798 enum CaseType 2799 { 2800 CASE_VERTEX_FRAGMENT = 0, 2801 CASE_VERTEX_GEO_FRAGMENT, 2802 CASE_VERTEX_TESS_FRAGMENT, 2803 CASE_VERTEX_TESS_GEO_FRAGMENT, 2804 2805 CASE_SEPARABLE_VERTEX, 2806 CASE_SEPARABLE_FRAGMENT, 2807 CASE_SEPARABLE_GEOMETRY, 2808 CASE_SEPARABLE_TESS_CTRL, 2809 CASE_SEPARABLE_TESS_EVAL, 2810 2811 CASE_LAST 2812 }; 2813 ProgramInputOutputReferencedByCase (Context& context, const char* name, const char* description, glu::Storage targetStorage, CaseType caseType); 2814 ~ProgramInputOutputReferencedByCase (void); 2815 2816 private: 2817 void init (void); 2818 void deinit (void); 2819 IterateResult iterate (void); 2820 2821 const CaseType m_caseType; 2822 const glu::Storage m_targetStorage; 2823 ProgramInterfaceDefinition::Program* m_program; 2824 }; 2825 2826 ProgramInputOutputReferencedByCase::ProgramInputOutputReferencedByCase (Context& context, const char* name, const char* description, glu::Storage targetStorage, CaseType caseType) 2827 : TestCase (context, name, description) 2828 , m_caseType (caseType) 2829 , m_targetStorage (targetStorage) 2830 , m_program (DE_NULL) 2831 { 2832 DE_ASSERT(caseType < CASE_LAST); 2833 } 2834 2835 ProgramInputOutputReferencedByCase::~ProgramInputOutputReferencedByCase (void) 2836 { 2837 deinit(); 2838 } 2839 2840 void ProgramInputOutputReferencedByCase::init (void) 2841 { 2842 const bool hasTessellationShader = (m_caseType == CASE_VERTEX_TESS_FRAGMENT) || 2843 (m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT) || 2844 (m_caseType == CASE_SEPARABLE_TESS_CTRL) || 2845 (m_caseType == CASE_SEPARABLE_TESS_EVAL); 2846 const bool hasGeometryShader = (m_caseType == CASE_VERTEX_GEO_FRAGMENT) || 2847 (m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT) || 2848 (m_caseType == CASE_SEPARABLE_GEOMETRY); 2849 2850 if (hasTessellationShader && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader")) 2851 throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader extension"); 2852 if (hasGeometryShader && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) 2853 throw tcu::NotSupportedError("Test requires GL_EXT_geometry_shader extension"); 2854 2855 m_program = new ProgramInterfaceDefinition::Program(); 2856 2857 if (m_caseType == CASE_SEPARABLE_VERTEX || 2858 m_caseType == CASE_SEPARABLE_FRAGMENT || 2859 m_caseType == CASE_SEPARABLE_GEOMETRY || 2860 m_caseType == CASE_SEPARABLE_TESS_CTRL || 2861 m_caseType == CASE_SEPARABLE_TESS_EVAL) 2862 { 2863 const bool isInputCase = (m_targetStorage == glu::STORAGE_IN || m_targetStorage == glu::STORAGE_PATCH_IN); 2864 const bool perPatchStorage = (m_targetStorage == glu::STORAGE_PATCH_IN || m_targetStorage == glu::STORAGE_PATCH_OUT); 2865 const char* varName = (isInputCase) ? ("shaderInput") : ("shaderOutput"); 2866 const glu::VariableDeclaration targetDecl (glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), varName, m_targetStorage); 2867 const glu::ShaderType shaderType = (m_caseType == CASE_SEPARABLE_VERTEX) ? (glu::SHADERTYPE_VERTEX) 2868 : (m_caseType == CASE_SEPARABLE_FRAGMENT) ? (glu::SHADERTYPE_FRAGMENT) 2869 : (m_caseType == CASE_SEPARABLE_GEOMETRY) ? (glu::SHADERTYPE_GEOMETRY) 2870 : (m_caseType == CASE_SEPARABLE_TESS_CTRL) ? (glu::SHADERTYPE_TESSELLATION_CONTROL) 2871 : (m_caseType == CASE_SEPARABLE_TESS_EVAL) ? (glu::SHADERTYPE_TESSELLATION_EVALUATION) 2872 : (glu::SHADERTYPE_LAST); 2873 const bool arrayedInterface = (isInputCase) ? ((shaderType == glu::SHADERTYPE_GEOMETRY) || 2874 (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL) || 2875 (shaderType == glu::SHADERTYPE_TESSELLATION_EVALUATION)) 2876 : (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL); 2877 2878 m_program->setSeparable(true); 2879 2880 if (arrayedInterface && !perPatchStorage) 2881 { 2882 const glu::VariableDeclaration targetDeclArr(glu::VarType(targetDecl.varType, glu::VarType::UNSIZED_ARRAY), varName, m_targetStorage); 2883 m_program->addShader(shaderType, glu::GLSL_VERSION_310_ES)->getDefaultBlock().variables.push_back(targetDeclArr); 2884 } 2885 else 2886 { 2887 m_program->addShader(shaderType, glu::GLSL_VERSION_310_ES)->getDefaultBlock().variables.push_back(targetDecl); 2888 } 2889 } 2890 else if (m_caseType == CASE_VERTEX_FRAGMENT || 2891 m_caseType == CASE_VERTEX_GEO_FRAGMENT || 2892 m_caseType == CASE_VERTEX_TESS_FRAGMENT || 2893 m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT) 2894 { 2895 ProgramInterfaceDefinition::Shader* vertex = m_program->addShader(glu::SHADERTYPE_VERTEX, glu::GLSL_VERSION_310_ES); 2896 ProgramInterfaceDefinition::Shader* fragment = m_program->addShader(glu::SHADERTYPE_FRAGMENT, glu::GLSL_VERSION_310_ES); 2897 2898 m_program->setSeparable(false); 2899 2900 vertex->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), 2901 "shaderInput", 2902 glu::STORAGE_IN)); 2903 vertex->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), 2904 "shaderOutput", 2905 glu::STORAGE_OUT, 2906 glu::INTERPOLATION_LAST, 2907 glu::Layout(1))); 2908 2909 fragment->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), 2910 "shaderOutput", 2911 glu::STORAGE_OUT, 2912 glu::INTERPOLATION_LAST, 2913 glu::Layout(0))); 2914 fragment->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), 2915 "shaderInput", 2916 glu::STORAGE_IN, 2917 glu::INTERPOLATION_LAST, 2918 glu::Layout(1))); 2919 2920 if (m_caseType == CASE_VERTEX_TESS_FRAGMENT || m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT) 2921 { 2922 ProgramInterfaceDefinition::Shader* tessCtrl = m_program->addShader(glu::SHADERTYPE_TESSELLATION_CONTROL, glu::GLSL_VERSION_310_ES); 2923 ProgramInterfaceDefinition::Shader* tessEval = m_program->addShader(glu::SHADERTYPE_TESSELLATION_EVALUATION, glu::GLSL_VERSION_310_ES); 2924 2925 tessCtrl->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY), 2926 "shaderInput", 2927 glu::STORAGE_IN, 2928 glu::INTERPOLATION_LAST, 2929 glu::Layout(1))); 2930 tessCtrl->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY), 2931 "shaderOutput", 2932 glu::STORAGE_OUT, 2933 glu::INTERPOLATION_LAST, 2934 glu::Layout(1))); 2935 2936 tessEval->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY), 2937 "shaderInput", 2938 glu::STORAGE_IN, 2939 glu::INTERPOLATION_LAST, 2940 glu::Layout(1))); 2941 tessEval->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), 2942 "shaderOutput", 2943 glu::STORAGE_OUT, 2944 glu::INTERPOLATION_LAST, 2945 glu::Layout(1))); 2946 } 2947 2948 if (m_caseType == CASE_VERTEX_GEO_FRAGMENT || m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT) 2949 { 2950 ProgramInterfaceDefinition::Shader* geometry = m_program->addShader(glu::SHADERTYPE_GEOMETRY, glu::GLSL_VERSION_310_ES); 2951 2952 geometry->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY), 2953 "shaderInput", 2954 glu::STORAGE_IN, 2955 glu::INTERPOLATION_LAST, 2956 glu::Layout(1))); 2957 geometry->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), 2958 "shaderOutput", 2959 glu::STORAGE_OUT, 2960 glu::INTERPOLATION_LAST, 2961 glu::Layout(1))); 2962 } 2963 } 2964 else 2965 DE_ASSERT(false); 2966 2967 if (m_program->hasStage(glu::SHADERTYPE_GEOMETRY)) 2968 m_program->setGeometryNumOutputVertices(1); 2969 if (m_program->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || m_program->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION)) 2970 m_program->setTessellationNumOutputPatchVertices(1); 2971 2972 DE_ASSERT(m_program->isValid()); 2973 } 2974 2975 void ProgramInputOutputReferencedByCase::deinit (void) 2976 { 2977 delete m_program; 2978 m_program = DE_NULL; 2979 } 2980 2981 ProgramInputOutputReferencedByCase::IterateResult ProgramInputOutputReferencedByCase::iterate (void) 2982 { 2983 static const struct 2984 { 2985 glw::GLenum propName; 2986 glu::ShaderType shaderType; 2987 const char* extension; 2988 } targetProps[] = 2989 { 2990 { GL_REFERENCED_BY_VERTEX_SHADER, glu::SHADERTYPE_VERTEX, DE_NULL }, 2991 { GL_REFERENCED_BY_FRAGMENT_SHADER, glu::SHADERTYPE_FRAGMENT, DE_NULL }, 2992 { GL_REFERENCED_BY_COMPUTE_SHADER, glu::SHADERTYPE_COMPUTE, DE_NULL }, 2993 { GL_REFERENCED_BY_TESS_CONTROL_SHADER, glu::SHADERTYPE_TESSELLATION_CONTROL, "GL_EXT_tessellation_shader" }, 2994 { GL_REFERENCED_BY_TESS_EVALUATION_SHADER, glu::SHADERTYPE_TESSELLATION_EVALUATION, "GL_EXT_tessellation_shader" }, 2995 { GL_REFERENCED_BY_GEOMETRY_SHADER, glu::SHADERTYPE_GEOMETRY, "GL_EXT_geometry_shader" }, 2996 }; 2997 2998 const bool isInputCase = (m_targetStorage == glu::STORAGE_IN || m_targetStorage == glu::STORAGE_PATCH_IN); 2999 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3000 const glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program)); 3001 const std::string targetResourceName = (isInputCase) ? ("shaderInput") : ("shaderOutput"); 3002 const glw::GLenum programGLInterface = (isInputCase) ? (GL_PROGRAM_INPUT) : (GL_PROGRAM_OUTPUT); 3003 glw::GLuint resourceIndex; 3004 3005 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 3006 checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 3007 3008 // find target resource index 3009 3010 resourceIndex = gl.getProgramResourceIndex(program.getProgram(), programGLInterface, targetResourceName.c_str()); 3011 GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index"); 3012 3013 if (resourceIndex == GL_INVALID_INDEX) 3014 { 3015 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for resource \"" << targetResourceName << "\" index returned invalid index." << tcu::TestLog::EndMessage; 3016 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "could not find target resource"); 3017 return STOP; 3018 } 3019 3020 // check props 3021 for (int propNdx = 0; propNdx < DE_LENGTH_OF_ARRAY(targetProps); ++propNdx) 3022 { 3023 if (targetProps[propNdx].extension == DE_NULL || m_context.getContextInfo().isExtensionSupported(targetProps[propNdx].extension)) 3024 { 3025 const glw::GLenum prop = targetProps[propNdx].propName; 3026 const bool expected = (isInputCase) ? (targetProps[propNdx].shaderType == m_program->getFirstStage()) : (targetProps[propNdx].shaderType == m_program->getLastStage()); 3027 glw::GLint value = -1; 3028 glw::GLint written = -1; 3029 3030 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying " << glu::getProgramResourcePropertyName(prop) << ", expecting " << ((expected) ? ("TRUE") : ("FALSE")) << tcu::TestLog::EndMessage; 3031 3032 gl.getProgramResourceiv(program.getProgram(), programGLInterface, resourceIndex, 1, &prop, 1, &written, &value); 3033 GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer binding"); 3034 3035 if (written != 1) 3036 { 3037 m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for referenced_by_* returned invalid number of values." << tcu::TestLog::EndMessage; 3038 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "property query failed"); 3039 continue; 3040 } 3041 3042 m_testCtx.getLog() << tcu::TestLog::Message << glu::getProgramResourcePropertyName(prop) << " = " << glu::getBooleanStr(value) << tcu::TestLog::EndMessage; 3043 3044 if (value != ((expected) ? (GL_TRUE) : (GL_FALSE))) 3045 { 3046 m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected value" << tcu::TestLog::EndMessage; 3047 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "unexpected property value"); 3048 continue; 3049 } 3050 } 3051 } 3052 3053 return STOP; 3054 } 3055 3056 class FeedbackResourceListTestCase : public ResourceListTestCase 3057 { 3058 public: 3059 FeedbackResourceListTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& resource, const char* name); 3060 ~FeedbackResourceListTestCase (void); 3061 3062 private: 3063 IterateResult iterate (void); 3064 }; 3065 3066 FeedbackResourceListTestCase::FeedbackResourceListTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& resource, const char* name) 3067 : ResourceListTestCase(context, resource, PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, name) 3068 { 3069 } 3070 3071 FeedbackResourceListTestCase::~FeedbackResourceListTestCase (void) 3072 { 3073 deinit(); 3074 } 3075 3076 FeedbackResourceListTestCase::IterateResult FeedbackResourceListTestCase::iterate (void) 3077 { 3078 const glu::ShaderProgram program(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_programDefinition)); 3079 3080 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 3081 3082 // Feedback varyings 3083 { 3084 tcu::MessageBuilder builder(&m_testCtx.getLog()); 3085 builder << "Transform feedback varyings: {"; 3086 for (int ndx = 0; ndx < (int)m_programDefinition->getTransformFeedbackVaryings().size(); ++ndx) 3087 { 3088 if (ndx) 3089 builder << ", "; 3090 builder << "\"" << m_programDefinition->getTransformFeedbackVaryings()[ndx] << "\""; 3091 } 3092 builder << "}" << tcu::TestLog::EndMessage; 3093 } 3094 3095 checkAndLogProgram(program, m_programDefinition, m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 3096 3097 // Check resource list 3098 { 3099 const tcu::ScopedLogSection section (m_testCtx.getLog(), "ResourceList", "Resource list"); 3100 std::vector<std::string> resourceList; 3101 std::vector<std::string> expectedResources; 3102 3103 queryResourceList(resourceList, program.getProgram()); 3104 expectedResources = getProgramInterfaceResourceList(m_programDefinition, m_programInterface); 3105 3106 // verify the list and the expected list match 3107 3108 if (!verifyResourceList(resourceList, expectedResources)) 3109 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid resource list"); 3110 3111 // verify GetProgramResourceIndex() matches the indices of the list 3112 3113 if (!verifyResourceIndexQuery(resourceList, expectedResources, program.getProgram())) 3114 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "GetProgramResourceIndex returned unexpected values"); 3115 3116 // Verify MAX_NAME_LENGTH 3117 if (!verifyMaxNameLength(resourceList, program.getProgram())) 3118 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "MAX_NAME_LENGTH invalid"); 3119 } 3120 3121 return STOP; 3122 } 3123 3124 int InterfaceBlockDataSizeTestCase::getBlockMinDataSize (const glu::InterfaceBlock& block) const 3125 { 3126 int dataSize = 0; 3127 3128 for (int ndx = 0; ndx < (int)block.variables.size(); ++ndx) 3129 dataSize += getVarTypeSize(block.variables[ndx].varType); 3130 3131 return dataSize; 3132 } 3133 3134 static bool isDataTypeLayoutQualified (glu::DataType type) 3135 { 3136 return glu::isDataTypeImage(type) || glu::isDataTypeAtomicCounter(type); 3137 } 3138 3139 static void generateVariableCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel = 3, bool createTestGroup = true) 3140 { 3141 static const struct 3142 { 3143 int level; 3144 glu::DataType dataType; 3145 } variableTypes[] = 3146 { 3147 { 0, glu::TYPE_FLOAT }, 3148 { 1, glu::TYPE_INT }, 3149 { 1, glu::TYPE_UINT }, 3150 { 1, glu::TYPE_BOOL }, 3151 3152 { 3, glu::TYPE_FLOAT_VEC2 }, 3153 { 1, glu::TYPE_FLOAT_VEC3 }, 3154 { 1, glu::TYPE_FLOAT_VEC4 }, 3155 3156 { 3, glu::TYPE_INT_VEC2 }, 3157 { 2, glu::TYPE_INT_VEC3 }, 3158 { 3, glu::TYPE_INT_VEC4 }, 3159 3160 { 3, glu::TYPE_UINT_VEC2 }, 3161 { 2, glu::TYPE_UINT_VEC3 }, 3162 { 3, glu::TYPE_UINT_VEC4 }, 3163 3164 { 3, glu::TYPE_BOOL_VEC2 }, 3165 { 2, glu::TYPE_BOOL_VEC3 }, 3166 { 3, glu::TYPE_BOOL_VEC4 }, 3167 3168 { 2, glu::TYPE_FLOAT_MAT2 }, 3169 { 3, glu::TYPE_FLOAT_MAT2X3 }, 3170 { 3, glu::TYPE_FLOAT_MAT2X4 }, 3171 { 2, glu::TYPE_FLOAT_MAT3X2 }, 3172 { 2, glu::TYPE_FLOAT_MAT3 }, 3173 { 3, glu::TYPE_FLOAT_MAT3X4 }, 3174 { 2, glu::TYPE_FLOAT_MAT4X2 }, 3175 { 3, glu::TYPE_FLOAT_MAT4X3 }, 3176 { 2, glu::TYPE_FLOAT_MAT4 }, 3177 }; 3178 3179 tcu::TestCaseGroup* group; 3180 3181 if (createTestGroup) 3182 { 3183 group = new tcu::TestCaseGroup(context.getTestContext(), "basic_type", "Basic variable"); 3184 targetGroup->addChild(group); 3185 } 3186 else 3187 group = targetGroup; 3188 3189 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx) 3190 { 3191 if (variableTypes[ndx].level <= expandLevel) 3192 { 3193 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].dataType)); 3194 group->addChild(new ResourceTestCase(context, variable, queryTarget)); 3195 } 3196 } 3197 } 3198 3199 static void generateOpaqueTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel = 3, bool createTestGroup = true) 3200 { 3201 static const struct 3202 { 3203 int level; 3204 glu::DataType dataType; 3205 } variableTypes[] = 3206 { 3207 { 0, glu::TYPE_SAMPLER_2D }, 3208 { 2, glu::TYPE_SAMPLER_CUBE }, 3209 { 1, glu::TYPE_SAMPLER_2D_ARRAY }, 3210 { 1, glu::TYPE_SAMPLER_3D }, 3211 { 2, glu::TYPE_SAMPLER_2D_SHADOW }, 3212 { 3, glu::TYPE_SAMPLER_CUBE_SHADOW }, 3213 { 3, glu::TYPE_SAMPLER_2D_ARRAY_SHADOW }, 3214 { 1, glu::TYPE_INT_SAMPLER_2D }, 3215 { 3, glu::TYPE_INT_SAMPLER_CUBE }, 3216 { 3, glu::TYPE_INT_SAMPLER_2D_ARRAY }, 3217 { 3, glu::TYPE_INT_SAMPLER_3D }, 3218 { 2, glu::TYPE_UINT_SAMPLER_2D }, 3219 { 3, glu::TYPE_UINT_SAMPLER_CUBE }, 3220 { 3, glu::TYPE_UINT_SAMPLER_2D_ARRAY }, 3221 { 3, glu::TYPE_UINT_SAMPLER_3D }, 3222 { 2, glu::TYPE_SAMPLER_2D_MULTISAMPLE }, 3223 { 2, glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE }, 3224 { 3, glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE }, 3225 { 1, glu::TYPE_IMAGE_2D }, 3226 { 3, glu::TYPE_IMAGE_CUBE }, 3227 { 3, glu::TYPE_IMAGE_2D_ARRAY }, 3228 { 3, glu::TYPE_IMAGE_3D }, 3229 { 3, glu::TYPE_INT_IMAGE_2D }, 3230 { 3, glu::TYPE_INT_IMAGE_CUBE }, 3231 { 1, glu::TYPE_INT_IMAGE_2D_ARRAY }, 3232 { 3, glu::TYPE_INT_IMAGE_3D }, 3233 { 2, glu::TYPE_UINT_IMAGE_2D }, 3234 { 3, glu::TYPE_UINT_IMAGE_CUBE }, 3235 { 3, glu::TYPE_UINT_IMAGE_2D_ARRAY }, 3236 { 3, glu::TYPE_UINT_IMAGE_3D }, 3237 { 1, glu::TYPE_UINT_ATOMIC_COUNTER }, 3238 }; 3239 3240 bool isStructMember = false; 3241 3242 // Requirements 3243 for (const ResourceDefinition::Node* node = parentStructure.get(); node; node = node->getEnclosingNode()) 3244 { 3245 // Don't insert inside a interface block 3246 if (node->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK) 3247 return; 3248 3249 isStructMember |= (node->getType() == ResourceDefinition::Node::TYPE_STRUCT_MEMBER); 3250 } 3251 3252 // Add cases 3253 { 3254 tcu::TestCaseGroup* group; 3255 3256 if (createTestGroup) 3257 { 3258 group = new tcu::TestCaseGroup(context.getTestContext(), "opaque_type", "Opaque types"); 3259 targetGroup->addChild(group); 3260 } 3261 else 3262 group = targetGroup; 3263 3264 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx) 3265 { 3266 if (variableTypes[ndx].level > expandLevel) 3267 continue; 3268 3269 // Layout qualifiers are not allowed on struct members 3270 if (isDataTypeLayoutQualified(variableTypes[ndx].dataType) && isStructMember) 3271 continue; 3272 3273 { 3274 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].dataType)); 3275 group->addChild(new ResourceTestCase(context, variable, queryTarget)); 3276 } 3277 } 3278 } 3279 } 3280 3281 static void generateCompoundVariableCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel = 3); 3282 3283 static void generateVariableArrayCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel = 3) 3284 { 3285 if (expandLevel > 0) 3286 { 3287 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure)); 3288 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "array", "Arrays"); 3289 3290 targetGroup->addChild(blockGroup); 3291 3292 // Arrays of basic variables 3293 generateVariableCases(context, arrayElement, blockGroup, queryTarget, expandLevel, expandLevel != 1); 3294 3295 // Arrays of opaque types 3296 generateOpaqueTypeCases(context, arrayElement, blockGroup, queryTarget, expandLevel, expandLevel != 1); 3297 3298 // Arrays of arrays 3299 generateVariableArrayCases(context, arrayElement, blockGroup, queryTarget, expandLevel-1); 3300 3301 // Arrays of structs 3302 generateCompoundVariableCases(context, arrayElement, blockGroup, queryTarget, expandLevel-1); 3303 } 3304 } 3305 3306 static void generateCompoundVariableCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel) 3307 { 3308 if (expandLevel > 0) 3309 { 3310 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure)); 3311 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "struct", "Structs"); 3312 3313 targetGroup->addChild(blockGroup); 3314 3315 // Struct containing basic variable 3316 generateVariableCases(context, structMember, blockGroup, queryTarget, expandLevel, expandLevel != 1); 3317 3318 // Struct containing opaque types 3319 generateOpaqueTypeCases(context, structMember, blockGroup, queryTarget, expandLevel, expandLevel != 1); 3320 3321 // Struct containing arrays 3322 generateVariableArrayCases(context, structMember, blockGroup, queryTarget, expandLevel-1); 3323 3324 // Struct containing struct 3325 generateCompoundVariableCases(context, structMember, blockGroup, queryTarget, expandLevel-1); 3326 } 3327 } 3328 3329 // Resource list cases 3330 3331 enum BlockFlags 3332 { 3333 BLOCKFLAG_DEFAULT = 0x01, 3334 BLOCKFLAG_NAMED = 0x02, 3335 BLOCKFLAG_UNNAMED = 0x04, 3336 BLOCKFLAG_ARRAY = 0x08, 3337 3338 BLOCKFLAG_ALL = 0x0F 3339 }; 3340 3341 static void generateUniformCaseBlocks (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, deUint32 blockFlags, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup* const)) 3342 { 3343 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure)); 3344 const ResourceDefinition::Node::SharedPtr uniform (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM)); 3345 3346 // .default_block 3347 if (blockFlags & BLOCKFLAG_DEFAULT) 3348 { 3349 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "default_block", "Default block"); 3350 targetGroup->addChild(blockGroup); 3351 3352 blockContentGenerator(context, uniform, blockGroup); 3353 } 3354 3355 // .named_block 3356 if (blockFlags & BLOCKFLAG_NAMED) 3357 { 3358 const ResourceDefinition::Node::SharedPtr block(new ResourceDefinition::InterfaceBlock(uniform, true)); 3359 3360 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "named_block", "Named uniform block"); 3361 targetGroup->addChild(blockGroup); 3362 3363 blockContentGenerator(context, block, blockGroup); 3364 } 3365 3366 // .unnamed_block 3367 if (blockFlags & BLOCKFLAG_UNNAMED) 3368 { 3369 const ResourceDefinition::Node::SharedPtr block(new ResourceDefinition::InterfaceBlock(uniform, false)); 3370 3371 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "unnamed_block", "Unnamed uniform block"); 3372 targetGroup->addChild(blockGroup); 3373 3374 blockContentGenerator(context, block, blockGroup); 3375 } 3376 3377 // .block_array 3378 if (blockFlags & BLOCKFLAG_ARRAY) 3379 { 3380 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(uniform)); 3381 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true)); 3382 3383 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "block_array", "Uniform block array"); 3384 targetGroup->addChild(blockGroup); 3385 3386 blockContentGenerator(context, block, blockGroup); 3387 } 3388 } 3389 3390 static void generateBufferBackedResourceListBlockContentCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, int depth) 3391 { 3392 // variable 3393 { 3394 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, glu::TYPE_FLOAT_VEC4)); 3395 targetGroup->addChild(new ResourceListTestCase(context, variable, interface)); 3396 } 3397 3398 // struct 3399 if (depth > 0) 3400 { 3401 const ResourceDefinition::Node::SharedPtr structMember(new ResourceDefinition::StructMember(parentStructure)); 3402 generateBufferBackedResourceListBlockContentCases(context, structMember, targetGroup, interface, depth - 1); 3403 } 3404 3405 // array 3406 if (depth > 0) 3407 { 3408 const ResourceDefinition::Node::SharedPtr arrayElement(new ResourceDefinition::ArrayElement(parentStructure)); 3409 generateBufferBackedResourceListBlockContentCases(context, arrayElement, targetGroup, interface, depth - 1); 3410 } 3411 } 3412 3413 static void generateBufferBackedVariableAggregateTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, ProgramResourcePropFlags targetProp, glu::DataType dataType, const std::string& nameSuffix, int depth) 3414 { 3415 // variable 3416 { 3417 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, dataType)); 3418 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(interface, targetProp), ("var" + nameSuffix).c_str())); 3419 } 3420 3421 // struct 3422 if (depth > 0) 3423 { 3424 const ResourceDefinition::Node::SharedPtr structMember(new ResourceDefinition::StructMember(parentStructure)); 3425 generateBufferBackedVariableAggregateTypeCases(context, structMember, targetGroup, interface, targetProp, dataType, "_struct" + nameSuffix, depth - 1); 3426 } 3427 3428 // array 3429 if (depth > 0) 3430 { 3431 const ResourceDefinition::Node::SharedPtr arrayElement(new ResourceDefinition::ArrayElement(parentStructure)); 3432 generateBufferBackedVariableAggregateTypeCases(context, arrayElement, targetGroup, interface, targetProp, dataType, "_array" + nameSuffix, depth - 1); 3433 } 3434 } 3435 3436 static void generateUniformResourceListBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup) 3437 { 3438 generateBufferBackedResourceListBlockContentCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_UNIFORM, 4); 3439 } 3440 3441 static void generateUniformBlockArraySizeContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup) 3442 { 3443 const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_ARRAY_SIZE); 3444 const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK); 3445 const bool namedNonArrayBlock = isInterfaceBlock && 3446 static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named && 3447 parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT; 3448 3449 if (!isInterfaceBlock || namedNonArrayBlock) 3450 { 3451 // .types 3452 { 3453 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types"); 3454 targetGroup->addChild(blockGroup); 3455 3456 generateVariableCases(context, parentStructure, blockGroup, queryTarget, 2, false); 3457 generateOpaqueTypeCases(context, parentStructure, blockGroup, queryTarget, 2, false); 3458 } 3459 3460 // aggregates 3461 { 3462 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "Aggregate types"); 3463 targetGroup->addChild(blockGroup); 3464 3465 generateBufferBackedVariableAggregateTypeCases(context, parentStructure, blockGroup, queryTarget.interface, PROGRAMRESOURCEPROP_ARRAY_SIZE, glu::TYPE_FLOAT, "", 3); 3466 } 3467 } 3468 else 3469 { 3470 // aggregates 3471 generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, queryTarget.interface, PROGRAMRESOURCEPROP_ARRAY_SIZE, glu::TYPE_FLOAT, "", 2); 3472 } 3473 } 3474 3475 static void generateBufferBackedArrayStrideTypeAggregateSubCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const std::string& namePrefix, ProgramInterface interface, glu::DataType type, int expandLevel) 3476 { 3477 // case 3478 { 3479 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, type)); 3480 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(interface, PROGRAMRESOURCEPROP_ARRAY_STRIDE), namePrefix.c_str())); 3481 } 3482 3483 if (expandLevel > 0) 3484 { 3485 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure)); 3486 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure)); 3487 3488 // _struct 3489 generateBufferBackedArrayStrideTypeAggregateSubCases(context, structMember, targetGroup, namePrefix + "_struct", interface, type, expandLevel - 1); 3490 3491 // _array 3492 generateBufferBackedArrayStrideTypeAggregateSubCases(context, arrayElement, targetGroup, namePrefix + "_array", interface, type, expandLevel - 1); 3493 } 3494 } 3495 3496 static void generateBufferBackedArrayStrideTypeAggregateCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, glu::DataType type, int expandLevel, bool includeBaseCase) 3497 { 3498 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure)); 3499 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure)); 3500 const std::string namePrefix = glu::getDataTypeName(type); 3501 3502 if (expandLevel == 0 || includeBaseCase) 3503 { 3504 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, type)); 3505 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(interface, PROGRAMRESOURCEPROP_ARRAY_STRIDE), namePrefix.c_str())); 3506 } 3507 if (expandLevel >= 1) 3508 { 3509 // _struct 3510 if (!glu::isDataTypeAtomicCounter(type)) 3511 generateBufferBackedArrayStrideTypeAggregateSubCases(context, structMember, targetGroup, namePrefix + "_struct", interface, type, expandLevel - 1); 3512 3513 // _array 3514 generateBufferBackedArrayStrideTypeAggregateSubCases(context, arrayElement, targetGroup, namePrefix + "_array", interface, type, expandLevel - 1); 3515 } 3516 } 3517 3518 static void generateUniformBlockArrayStrideContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup) 3519 { 3520 const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_ARRAY_STRIDE); 3521 const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK); 3522 const bool namedNonArrayBlock = isInterfaceBlock && 3523 static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named && 3524 parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT; 3525 3526 if (!isInterfaceBlock || namedNonArrayBlock) 3527 { 3528 // .types 3529 { 3530 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types"); 3531 targetGroup->addChild(blockGroup); 3532 3533 generateVariableCases(context, parentStructure, blockGroup, queryTarget, 2, false); 3534 generateOpaqueTypeCases(context, parentStructure, blockGroup, queryTarget, 2, false); 3535 } 3536 3537 // .aggregates 3538 { 3539 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "Aggregate types"); 3540 targetGroup->addChild(blockGroup); 3541 3542 // .sampler_2d_* 3543 if (!isInterfaceBlock) 3544 generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_SAMPLER_2D, 1, false); 3545 3546 // .atomic_counter_* 3547 if (!isInterfaceBlock) 3548 { 3549 const ResourceDefinition::Node::SharedPtr layout(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, 0))); 3550 generateBufferBackedArrayStrideTypeAggregateCases(context, layout, blockGroup, queryTarget.interface, glu::TYPE_UINT_ATOMIC_COUNTER, 1, false); 3551 } 3552 3553 // .float_* 3554 generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_FLOAT, 2, false); 3555 3556 // .bool_* 3557 generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_BOOL, 1, false); 3558 3559 // .bvec3_* 3560 generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_BOOL_VEC3, 2, false); 3561 3562 // .vec3_* 3563 generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_FLOAT_VEC3, 2, false); 3564 3565 // .ivec2_* 3566 generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_INT_VEC3, 2, false); 3567 } 3568 } 3569 else 3570 { 3571 generateVariableCases(context, parentStructure, targetGroup, queryTarget, 1); 3572 generateVariableArrayCases(context, parentStructure, targetGroup, queryTarget, 1); 3573 generateCompoundVariableCases(context, parentStructure, targetGroup, queryTarget, 1); 3574 } 3575 } 3576 3577 static void generateUniformBlockLocationContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup) 3578 { 3579 const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_LOCATION); 3580 const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK); 3581 3582 if (!isInterfaceBlock) 3583 { 3584 generateVariableCases(context, parentStructure, targetGroup, queryTarget, 3); 3585 generateOpaqueTypeCases(context, parentStructure, targetGroup, queryTarget, 3); 3586 generateVariableArrayCases(context, parentStructure, targetGroup, queryTarget, 2); 3587 generateCompoundVariableCases(context, parentStructure, targetGroup, queryTarget, 2); 3588 } 3589 else 3590 generateVariableCases(context, parentStructure, targetGroup, queryTarget, 1, false); 3591 } 3592 3593 static void generateUniformBlockBlockIndexContents (Context& context, tcu::TestCaseGroup* const targetGroup) 3594 { 3595 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 3596 const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES)); 3597 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 3598 const ResourceDefinition::Node::SharedPtr uniform (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM)); 3599 const ResourceDefinition::Node::SharedPtr binding (new ResourceDefinition::LayoutQualifier(uniform, glu::Layout(-1, 0))); 3600 3601 // .default_block 3602 { 3603 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(uniform, glu::TYPE_FLOAT_VEC4)); 3604 3605 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_BLOCK_INDEX), "default_block")); 3606 } 3607 3608 // .named_block 3609 { 3610 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, true)); 3611 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4)); 3612 3613 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_BLOCK_INDEX), "named_block")); 3614 } 3615 3616 // .unnamed_block 3617 { 3618 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, false)); 3619 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4)); 3620 3621 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_BLOCK_INDEX), "unnamed_block")); 3622 } 3623 3624 // .block_array 3625 { 3626 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding)); 3627 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(arrayElement, true)); 3628 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4)); 3629 3630 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_BLOCK_INDEX), "block_array")); 3631 } 3632 } 3633 3634 static void generateUniformBlockAtomicCounterBufferIndexContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup) 3635 { 3636 const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_ATOMIC_COUNTER_BUFFER_INDEX); 3637 const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK); 3638 3639 if (!isInterfaceBlock) 3640 { 3641 generateVariableCases(context, parentStructure, targetGroup, queryTarget, 3); 3642 generateOpaqueTypeCases(context, parentStructure, targetGroup, queryTarget, 3); 3643 3644 // .array 3645 { 3646 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure)); 3647 const ResourceDefinition::Node::SharedPtr arrayArrayElement (new ResourceDefinition::ArrayElement(arrayElement)); 3648 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElement, glu::TYPE_UINT_ATOMIC_COUNTER)); 3649 const ResourceDefinition::Node::SharedPtr elementvariable (new ResourceDefinition::Variable(arrayArrayElement, glu::TYPE_UINT_ATOMIC_COUNTER)); 3650 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "array", "Arrays"); 3651 3652 targetGroup->addChild(blockGroup); 3653 3654 blockGroup->addChild(new ResourceTestCase(context, variable, queryTarget, "var_array")); 3655 blockGroup->addChild(new ResourceTestCase(context, elementvariable, queryTarget, "var_array_array")); 3656 } 3657 } 3658 else 3659 generateVariableCases(context, parentStructure, targetGroup, queryTarget, 1, false); 3660 } 3661 3662 static void generateUniformBlockNameLengthContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup) 3663 { 3664 const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK); 3665 const bool namedNonArrayBlock = isInterfaceBlock && 3666 static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named && 3667 parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT; 3668 3669 if (!isInterfaceBlock || namedNonArrayBlock) 3670 generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 2); 3671 else 3672 generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 1); 3673 } 3674 3675 static void generateUniformBlockTypeContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup) 3676 { 3677 const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_TYPE); 3678 const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK); 3679 const bool namedNonArrayBlock = isInterfaceBlock && 3680 static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named && 3681 parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT; 3682 3683 if (!isInterfaceBlock || namedNonArrayBlock) 3684 { 3685 // .types 3686 { 3687 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types"); 3688 targetGroup->addChild(blockGroup); 3689 3690 generateVariableCases(context, parentStructure, blockGroup, queryTarget, 3, false); 3691 generateOpaqueTypeCases(context, parentStructure, blockGroup, queryTarget, 3, false); 3692 } 3693 3694 generateVariableArrayCases(context, parentStructure, targetGroup, queryTarget, 1); 3695 generateCompoundVariableCases(context, parentStructure, targetGroup, queryTarget, 1); 3696 3697 } 3698 else 3699 { 3700 generateVariableCases(context, parentStructure, targetGroup, queryTarget, 1); 3701 generateVariableArrayCases(context, parentStructure, targetGroup, queryTarget, 1); 3702 generateCompoundVariableCases(context, parentStructure, targetGroup, queryTarget, 1); 3703 } 3704 } 3705 3706 static void generateUniformBlockOffsetContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup) 3707 { 3708 const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_OFFSET); 3709 const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK); 3710 const bool namedNonArrayBlock = isInterfaceBlock && 3711 static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named && 3712 parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT; 3713 3714 if (!isInterfaceBlock) 3715 { 3716 // .types 3717 { 3718 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types"); 3719 targetGroup->addChild(blockGroup); 3720 3721 generateVariableCases(context, parentStructure, blockGroup, queryTarget, 3, false); 3722 generateOpaqueTypeCases(context, parentStructure, blockGroup, queryTarget, 3, false); 3723 } 3724 3725 // .aggregates 3726 { 3727 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "Aggregate types"); 3728 targetGroup->addChild(blockGroup); 3729 3730 // .atomic_uint_struct 3731 // .atomic_uint_array 3732 { 3733 const ResourceDefinition::Node::SharedPtr offset (new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, -1, 4))); 3734 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(offset)); 3735 const ResourceDefinition::Node::SharedPtr elementVariable (new ResourceDefinition::Variable(arrayElement, glu::TYPE_UINT_ATOMIC_COUNTER)); 3736 3737 blockGroup->addChild(new ResourceTestCase(context, elementVariable, queryTarget, "atomic_uint_array")); 3738 } 3739 3740 // .float_array 3741 // .float_struct 3742 { 3743 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure)); 3744 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure)); 3745 const ResourceDefinition::Node::SharedPtr memberVariable (new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT)); 3746 const ResourceDefinition::Node::SharedPtr elementVariable (new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT)); 3747 3748 blockGroup->addChild(new ResourceTestCase(context, memberVariable, queryTarget, "float_struct")); 3749 blockGroup->addChild(new ResourceTestCase(context, elementVariable, queryTarget, "float_array")); 3750 } 3751 } 3752 } 3753 else if (namedNonArrayBlock) 3754 { 3755 // .types 3756 { 3757 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types"); 3758 targetGroup->addChild(blockGroup); 3759 3760 generateVariableCases(context, parentStructure, blockGroup, queryTarget, 3, false); 3761 generateOpaqueTypeCases(context, parentStructure, blockGroup, queryTarget, 3, false); 3762 } 3763 3764 // .aggregates 3765 { 3766 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "Aggregate types"); 3767 targetGroup->addChild(blockGroup); 3768 3769 // .float_array 3770 // .float_struct 3771 { 3772 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure)); 3773 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::StructMember(parentStructure)); 3774 const ResourceDefinition::Node::SharedPtr memberVariable (new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT)); 3775 const ResourceDefinition::Node::SharedPtr elementVariable (new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT)); 3776 3777 blockGroup->addChild(new ResourceTestCase(context, memberVariable, queryTarget, "float_struct")); 3778 blockGroup->addChild(new ResourceTestCase(context, elementVariable, queryTarget, "float_array")); 3779 } 3780 } 3781 } 3782 else 3783 { 3784 generateVariableCases(context, parentStructure, targetGroup, queryTarget, 1); 3785 generateVariableArrayCases(context, parentStructure, targetGroup, queryTarget, 1); 3786 generateCompoundVariableCases(context, parentStructure, targetGroup, queryTarget, 1); 3787 } 3788 } 3789 3790 static void generateMatrixVariableCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, bool createTestGroup = true, int expandLevel = 2) 3791 { 3792 static const struct 3793 { 3794 int priority; 3795 glu::DataType type; 3796 } variableTypes[] = 3797 { 3798 { 0, glu::TYPE_FLOAT_MAT2 }, 3799 { 1, glu::TYPE_FLOAT_MAT2X3 }, 3800 { 2, glu::TYPE_FLOAT_MAT2X4 }, 3801 { 2, glu::TYPE_FLOAT_MAT3X2 }, 3802 { 1, glu::TYPE_FLOAT_MAT3 }, 3803 { 0, glu::TYPE_FLOAT_MAT3X4 }, 3804 { 2, glu::TYPE_FLOAT_MAT4X2 }, 3805 { 1, glu::TYPE_FLOAT_MAT4X3 }, 3806 { 0, glu::TYPE_FLOAT_MAT4 }, 3807 }; 3808 3809 tcu::TestCaseGroup* group; 3810 3811 if (createTestGroup) 3812 { 3813 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "matrix", "Basic matrix type"); 3814 targetGroup->addChild(blockGroup); 3815 group = blockGroup; 3816 } 3817 else 3818 group = targetGroup; 3819 3820 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx) 3821 { 3822 if (variableTypes[ndx].priority < expandLevel) 3823 { 3824 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].type)); 3825 group->addChild(new ResourceTestCase(context, variable, queryTarget)); 3826 } 3827 } 3828 } 3829 3830 static void generateMatrixStructCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel); 3831 3832 static void generateMatrixArrayCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel) 3833 { 3834 if (expandLevel > 0) 3835 { 3836 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure)); 3837 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "array", "Arrays"); 3838 3839 targetGroup->addChild(blockGroup); 3840 3841 // Arrays of basic variables 3842 generateMatrixVariableCases(context, arrayElement, blockGroup, queryTarget, expandLevel != 1, expandLevel); 3843 3844 // Arrays of arrays 3845 generateMatrixArrayCases(context, arrayElement, blockGroup, queryTarget, expandLevel-1); 3846 3847 // Arrays of structs 3848 generateMatrixStructCases(context, arrayElement, blockGroup, queryTarget, expandLevel-1); 3849 } 3850 } 3851 3852 static void generateMatrixStructCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel) 3853 { 3854 if (expandLevel > 0) 3855 { 3856 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure)); 3857 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "struct", "Structs"); 3858 3859 targetGroup->addChild(blockGroup); 3860 3861 // Struct containing basic variable 3862 generateMatrixVariableCases(context, structMember, blockGroup, queryTarget, expandLevel != 1, expandLevel); 3863 3864 // Struct containing arrays 3865 generateMatrixArrayCases(context, structMember, blockGroup, queryTarget, expandLevel-1); 3866 3867 // Struct containing struct 3868 generateMatrixStructCases(context, structMember, blockGroup, queryTarget, expandLevel-1); 3869 } 3870 } 3871 3872 static void generateUniformMatrixOrderCaseBlockContentCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, bool extendedBasicTypeCases, bool opaqueCases) 3873 { 3874 static const struct 3875 { 3876 const char* name; 3877 glu::MatrixOrder order; 3878 } qualifiers[] = 3879 { 3880 { "no_qualifier", glu::MATRIXORDER_LAST }, 3881 { "row_major", glu::MATRIXORDER_ROW_MAJOR }, 3882 { "column_major", glu::MATRIXORDER_COLUMN_MAJOR }, 3883 }; 3884 3885 const ProgramResourceQueryTestTarget queryTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR); 3886 3887 for (int qualifierNdx = 0; qualifierNdx < DE_LENGTH_OF_ARRAY(qualifiers); ++qualifierNdx) 3888 { 3889 // Add layout qualifiers only for block members 3890 if (qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST || parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK) 3891 { 3892 ResourceDefinition::Node::SharedPtr subStructure = parentStructure; 3893 tcu::TestCaseGroup* const qualifierGroup = new tcu::TestCaseGroup(context.getTestContext(), qualifiers[qualifierNdx].name, ""); 3894 3895 targetGroup->addChild(qualifierGroup); 3896 3897 if (qualifiers[qualifierNdx].order != glu::MATRIXORDER_LAST) 3898 { 3899 glu::Layout layout; 3900 layout.matrixOrder = qualifiers[qualifierNdx].order; 3901 subStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(subStructure, layout)); 3902 } 3903 3904 if (extendedBasicTypeCases && qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST) 3905 { 3906 // .types 3907 { 3908 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", ""); 3909 qualifierGroup->addChild(blockGroup); 3910 3911 generateVariableCases(context, subStructure, blockGroup, queryTarget, 1, false); 3912 generateMatrixVariableCases(context, subStructure, blockGroup, queryTarget, false); 3913 if (opaqueCases) 3914 generateOpaqueTypeCases(context, subStructure, blockGroup, queryTarget, 2, false); 3915 } 3916 3917 // .aggregates 3918 { 3919 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", ""); 3920 qualifierGroup->addChild(blockGroup); 3921 3922 generateBufferBackedVariableAggregateTypeCases(context, subStructure, blockGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1); 3923 } 3924 } 3925 else 3926 { 3927 generateBufferBackedVariableAggregateTypeCases(context, subStructure, qualifierGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1); 3928 } 3929 } 3930 } 3931 } 3932 3933 static void generateUniformMatrixStrideCaseBlockContentCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, bool extendedBasicTypeCases, bool opaqueCases) 3934 { 3935 static const struct 3936 { 3937 const char* name; 3938 glu::MatrixOrder order; 3939 } qualifiers[] = 3940 { 3941 { "no_qualifier", glu::MATRIXORDER_LAST }, 3942 { "row_major", glu::MATRIXORDER_ROW_MAJOR }, 3943 { "column_major", glu::MATRIXORDER_COLUMN_MAJOR }, 3944 }; 3945 3946 const ProgramResourceQueryTestTarget queryTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_MATRIX_STRIDE); 3947 3948 for (int qualifierNdx = 0; qualifierNdx < DE_LENGTH_OF_ARRAY(qualifiers); ++qualifierNdx) 3949 { 3950 // Add layout qualifiers only for block members 3951 if (qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST || parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK) 3952 { 3953 ResourceDefinition::Node::SharedPtr subStructure = parentStructure; 3954 tcu::TestCaseGroup* const qualifierGroup = new tcu::TestCaseGroup(context.getTestContext(), qualifiers[qualifierNdx].name, ""); 3955 3956 targetGroup->addChild(qualifierGroup); 3957 3958 if (qualifiers[qualifierNdx].order != glu::MATRIXORDER_LAST) 3959 { 3960 glu::Layout layout; 3961 layout.matrixOrder = qualifiers[qualifierNdx].order; 3962 subStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(subStructure, layout)); 3963 } 3964 3965 if (extendedBasicTypeCases) 3966 { 3967 // .types 3968 // .matrix 3969 if (qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST) 3970 { 3971 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", ""); 3972 qualifierGroup->addChild(blockGroup); 3973 3974 generateVariableCases(context, subStructure, blockGroup, queryTarget, 1, false); 3975 generateMatrixVariableCases(context, subStructure, blockGroup, queryTarget, false); 3976 if (opaqueCases) 3977 generateOpaqueTypeCases(context, subStructure, blockGroup, queryTarget, 2, false); 3978 } 3979 else 3980 generateMatrixVariableCases(context, subStructure, qualifierGroup, queryTarget); 3981 3982 // .aggregates 3983 { 3984 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", ""); 3985 qualifierGroup->addChild(blockGroup); 3986 3987 generateBufferBackedVariableAggregateTypeCases(context, subStructure, blockGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1); 3988 } 3989 } 3990 else 3991 generateBufferBackedVariableAggregateTypeCases(context, subStructure, qualifierGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1); 3992 } 3993 } 3994 } 3995 3996 static void generateUniformMatrixCaseBlocks (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup* const, bool, bool)) 3997 { 3998 static const struct 3999 { 4000 const char* name; 4001 const char* description; 4002 bool block; 4003 bool namedBlock; 4004 bool extendedBasicTypeCases; 4005 glu::MatrixOrder order; 4006 } children[] = 4007 { 4008 { "default_block", "Default block", false, true, true, glu::MATRIXORDER_LAST }, 4009 { "named_block", "Named uniform block", true, true, true, glu::MATRIXORDER_LAST }, 4010 { "named_block_row_major", "Named uniform block", true, true, false, glu::MATRIXORDER_ROW_MAJOR }, 4011 { "named_block_col_major", "Named uniform block", true, true, false, glu::MATRIXORDER_COLUMN_MAJOR }, 4012 { "unnamed_block", "Unnamed uniform block", true, false, false, glu::MATRIXORDER_LAST }, 4013 { "unnamed_block_row_major", "Unnamed uniform block", true, false, false, glu::MATRIXORDER_ROW_MAJOR }, 4014 { "unnamed_block_col_major", "Unnamed uniform block", true, false, false, glu::MATRIXORDER_COLUMN_MAJOR }, 4015 }; 4016 4017 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure)); 4018 const ResourceDefinition::Node::SharedPtr uniform (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM)); 4019 4020 for (int childNdx = 0; childNdx < (int)DE_LENGTH_OF_ARRAY(children); ++childNdx) 4021 { 4022 ResourceDefinition::Node::SharedPtr subStructure = uniform; 4023 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), children[childNdx].name, children[childNdx].description); 4024 const bool addOpaqueCases = children[childNdx].extendedBasicTypeCases && !children[childNdx].block; 4025 4026 targetGroup->addChild(blockGroup); 4027 4028 if (children[childNdx].order != glu::MATRIXORDER_LAST) 4029 { 4030 glu::Layout layout; 4031 layout.matrixOrder = children[childNdx].order; 4032 subStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(subStructure, layout)); 4033 } 4034 4035 if (children[childNdx].block) 4036 subStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::InterfaceBlock(subStructure, children[childNdx].namedBlock)); 4037 4038 blockContentGenerator(context, subStructure, blockGroup, children[childNdx].extendedBasicTypeCases, addOpaqueCases); 4039 } 4040 } 4041 4042 static void generateBufferReferencedByShaderInterfaceBlockCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, bool extendedCases) 4043 { 4044 const bool isDefaultBlock = (parentStructure->getType() != ResourceDefinition::Node::TYPE_INTERFACE_BLOCK); 4045 4046 // .float 4047 // .float_array 4048 // .float_struct 4049 { 4050 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(parentStructure, glu::TYPE_FLOAT)); 4051 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure)); 4052 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure)); 4053 const ResourceDefinition::Node::SharedPtr variableArray (new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT)); 4054 const ResourceDefinition::Node::SharedPtr variableStruct (new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT)); 4055 4056 targetGroup->addChild(new ResourceTestCase(context, variable, queryTarget, "float")); 4057 targetGroup->addChild(new ResourceTestCase(context, variableArray, queryTarget, "float_array")); 4058 targetGroup->addChild(new ResourceTestCase(context, variableStruct, queryTarget, "float_struct")); 4059 } 4060 4061 // .sampler 4062 // .sampler_array 4063 // .sampler_struct 4064 if (isDefaultBlock) 4065 { 4066 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, 0))); 4067 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_SAMPLER_2D)); 4068 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(layout)); 4069 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure)); 4070 const ResourceDefinition::Node::SharedPtr variableArray (new ResourceDefinition::Variable(arrayElement, glu::TYPE_SAMPLER_2D)); 4071 const ResourceDefinition::Node::SharedPtr variableStruct (new ResourceDefinition::Variable(structMember, glu::TYPE_SAMPLER_2D)); 4072 4073 targetGroup->addChild(new ResourceTestCase(context, variable, queryTarget, "sampler")); 4074 targetGroup->addChild(new ResourceTestCase(context, variableArray, queryTarget, "sampler_array")); 4075 targetGroup->addChild(new ResourceTestCase(context, variableStruct, queryTarget, "sampler_struct")); 4076 } 4077 4078 // .atomic_uint 4079 // .atomic_uint_array 4080 if (isDefaultBlock) 4081 { 4082 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, 0))); 4083 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_UINT_ATOMIC_COUNTER)); 4084 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(layout)); 4085 const ResourceDefinition::Node::SharedPtr variableArray (new ResourceDefinition::Variable(arrayElement, glu::TYPE_UINT_ATOMIC_COUNTER)); 4086 4087 targetGroup->addChild(new ResourceTestCase(context, variable, queryTarget, "atomic_uint")); 4088 targetGroup->addChild(new ResourceTestCase(context, variableArray, queryTarget, "atomic_uint_array")); 4089 } 4090 4091 if (extendedCases) 4092 { 4093 // .float_array_struct 4094 { 4095 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure)); 4096 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(structMember)); 4097 const ResourceDefinition::Node::SharedPtr variableArrayStruct (new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT)); 4098 4099 targetGroup->addChild(new ResourceTestCase(context, variableArrayStruct, queryTarget, "float_array_struct")); 4100 } 4101 4102 // .float_struct_array 4103 { 4104 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure)); 4105 const ResourceDefinition::Node::SharedPtr arrayStructMember (new ResourceDefinition::StructMember(arrayElement)); 4106 const ResourceDefinition::Node::SharedPtr variableArrayStruct (new ResourceDefinition::Variable(arrayStructMember, glu::TYPE_FLOAT)); 4107 4108 targetGroup->addChild(new ResourceTestCase(context, variableArrayStruct, queryTarget, "float_struct_array")); 4109 } 4110 4111 // .float_array_array 4112 { 4113 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure)); 4114 const ResourceDefinition::Node::SharedPtr subArrayElement (new ResourceDefinition::ArrayElement(arrayElement)); 4115 const ResourceDefinition::Node::SharedPtr variableArrayStruct (new ResourceDefinition::Variable(subArrayElement, glu::TYPE_FLOAT)); 4116 4117 targetGroup->addChild(new ResourceTestCase(context, variableArrayStruct, queryTarget, "float_array_array")); 4118 } 4119 4120 // .float_struct_struct 4121 { 4122 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure)); 4123 const ResourceDefinition::Node::SharedPtr subStructMember (new ResourceDefinition::StructMember(structMember)); 4124 const ResourceDefinition::Node::SharedPtr variableArrayStruct (new ResourceDefinition::Variable(subStructMember, glu::TYPE_FLOAT)); 4125 4126 targetGroup->addChild(new ResourceTestCase(context, variableArrayStruct, queryTarget, "float_struct_struct")); 4127 } 4128 4129 if (queryTarget.interface == PROGRAMINTERFACE_BUFFER_VARIABLE) 4130 { 4131 const ResourceDefinition::Node::SharedPtr arrayElement(new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 4132 4133 // .float_unsized_array 4134 { 4135 const ResourceDefinition::Node::SharedPtr variableArray (new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT)); 4136 4137 targetGroup->addChild(new ResourceTestCase(context, variableArray, queryTarget, "float_unsized_array")); 4138 } 4139 4140 // .float_unsized_struct_array 4141 { 4142 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(arrayElement)); 4143 const ResourceDefinition::Node::SharedPtr variableArray (new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT)); 4144 4145 targetGroup->addChild(new ResourceTestCase(context, variableArray, queryTarget, "float_unsized_struct_array")); 4146 } 4147 } 4148 } 4149 } 4150 4151 static void generateUniformReferencedByShaderSingleBlockContentCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, int expandLevel) 4152 { 4153 DE_UNREF(expandLevel); 4154 4155 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure)); 4156 const ResourceDefinition::Node::SharedPtr uniform (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM)); 4157 const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_REFERENCED_BY_SHADER); 4158 const bool singleShaderCase = parentStructure->getType() == ResourceDefinition::Node::TYPE_SHADER; 4159 4160 // .default_block 4161 { 4162 TestCaseGroup* const blockGroup = new TestCaseGroup(context, "default_block", ""); 4163 targetGroup->addChild(blockGroup); 4164 4165 generateBufferReferencedByShaderInterfaceBlockCases(context, uniform, blockGroup, queryTarget, singleShaderCase); 4166 } 4167 4168 // .named_block 4169 { 4170 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(uniform, true)); 4171 TestCaseGroup* const blockGroup = new TestCaseGroup(context, "uniform_block", ""); 4172 4173 targetGroup->addChild(blockGroup); 4174 4175 generateBufferReferencedByShaderInterfaceBlockCases(context, block, blockGroup, queryTarget, singleShaderCase); 4176 } 4177 4178 // .unnamed_block 4179 { 4180 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(uniform, false)); 4181 TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unnamed_block", ""); 4182 4183 targetGroup->addChild(blockGroup); 4184 4185 generateBufferReferencedByShaderInterfaceBlockCases(context, block, blockGroup, queryTarget, false); 4186 } 4187 4188 // .block_array 4189 { 4190 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(uniform)); 4191 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true)); 4192 TestCaseGroup* const blockGroup = new TestCaseGroup(context, "block_array", ""); 4193 4194 targetGroup->addChild(blockGroup); 4195 4196 generateBufferReferencedByShaderInterfaceBlockCases(context, block, blockGroup, queryTarget, false); 4197 } 4198 } 4199 4200 static void generateReferencedByShaderCaseBlocks (Context& context, tcu::TestCaseGroup* const targetGroup, void (*generateBlockContent)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, int expandLevel)) 4201 { 4202 static const struct 4203 { 4204 const char* name; 4205 glu::ShaderType stage; 4206 int expandLevel; 4207 } singleStageCases[] = 4208 { 4209 { "compute", glu::SHADERTYPE_COMPUTE, 3 }, 4210 { "separable_vertex", glu::SHADERTYPE_VERTEX, 2 }, 4211 { "separable_fragment", glu::SHADERTYPE_FRAGMENT, 2 }, 4212 { "separable_tess_ctrl", glu::SHADERTYPE_TESSELLATION_CONTROL, 2 }, 4213 { "separable_tess_eval", glu::SHADERTYPE_TESSELLATION_EVALUATION, 2 }, 4214 { "separable_geometry", glu::SHADERTYPE_GEOMETRY, 2 }, 4215 }; 4216 static const struct 4217 { 4218 const char* name; 4219 deUint32 flags; 4220 int expandLevel; 4221 int subExpandLevel; 4222 } pipelines[] = 4223 { 4224 { 4225 "vertex_fragment", 4226 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT), 4227 3, 4228 2, 4229 }, 4230 { 4231 "vertex_tess_fragment", 4232 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION), 4233 2, 4234 2, 4235 }, 4236 { 4237 "vertex_geo_fragment", 4238 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_GEOMETRY), 4239 2, 4240 2, 4241 }, 4242 { 4243 "vertex_tess_geo_fragment", 4244 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION) | (1 << glu::SHADERTYPE_GEOMETRY), 4245 2, 4246 1, 4247 }, 4248 }; 4249 4250 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(singleStageCases); ++ndx) 4251 { 4252 TestCaseGroup* const blockGroup = new TestCaseGroup(context, singleStageCases[ndx].name, ""); 4253 const bool programSeparable = (singleStageCases[ndx].stage != glu::SHADERTYPE_COMPUTE); 4254 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(programSeparable)); 4255 const ResourceDefinition::Node::SharedPtr stage (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glu::GLSL_VERSION_310_ES)); 4256 4257 targetGroup->addChild(blockGroup); 4258 4259 generateBlockContent(context, stage, blockGroup, singleStageCases[ndx].expandLevel); 4260 } 4261 4262 for (int pipelineNdx = 0; pipelineNdx < DE_LENGTH_OF_ARRAY(pipelines); ++pipelineNdx) 4263 { 4264 // whole pipeline 4265 { 4266 TestCaseGroup* const blockGroup = new TestCaseGroup(context, pipelines[pipelineNdx].name, ""); 4267 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 4268 ResourceDefinition::ShaderSet* shaderSet = new ResourceDefinition::ShaderSet(program, 4269 glu::GLSL_VERSION_310_ES, 4270 pipelines[pipelineNdx].flags, 4271 pipelines[pipelineNdx].flags); 4272 targetGroup->addChild(blockGroup); 4273 4274 { 4275 const ResourceDefinition::Node::SharedPtr shaders(shaderSet); 4276 generateBlockContent(context, shaders, blockGroup, pipelines[pipelineNdx].expandLevel); 4277 } 4278 } 4279 4280 // only one stage 4281 for (int selectedStageBit = 0; selectedStageBit < glu::SHADERTYPE_LAST; ++selectedStageBit) 4282 { 4283 if (pipelines[pipelineNdx].flags & (1 << selectedStageBit)) 4284 { 4285 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 4286 ResourceDefinition::ShaderSet* shaderSet = new ResourceDefinition::ShaderSet(program, 4287 glu::GLSL_VERSION_310_ES, 4288 pipelines[pipelineNdx].flags, 4289 (1u << selectedStageBit)); 4290 const char* stageName = (selectedStageBit == glu::SHADERTYPE_VERTEX) ? ("vertex") 4291 : (selectedStageBit == glu::SHADERTYPE_FRAGMENT) ? ("fragment") 4292 : (selectedStageBit == glu::SHADERTYPE_GEOMETRY) ? ("geo") 4293 : (selectedStageBit == glu::SHADERTYPE_TESSELLATION_CONTROL) ? ("tess_ctrl") 4294 : (selectedStageBit == glu::SHADERTYPE_TESSELLATION_EVALUATION) ? ("tess_eval") 4295 : (DE_NULL); 4296 const std::string setName = std::string() + pipelines[pipelineNdx].name + "_only_" + stageName; 4297 TestCaseGroup* const blockGroup = new TestCaseGroup(context, setName.c_str(), ""); 4298 const ResourceDefinition::Node::SharedPtr shaders (shaderSet); 4299 4300 generateBlockContent(context, shaders, blockGroup, pipelines[pipelineNdx].subExpandLevel); 4301 targetGroup->addChild(blockGroup); 4302 } 4303 } 4304 } 4305 } 4306 4307 static glu::DataType generateRandomDataType (de::Random& rnd, bool excludeOpaqueTypes) 4308 { 4309 static const glu::DataType s_types[] = 4310 { 4311 glu::TYPE_FLOAT, 4312 glu::TYPE_INT, 4313 glu::TYPE_UINT, 4314 glu::TYPE_BOOL, 4315 glu::TYPE_FLOAT_VEC2, 4316 glu::TYPE_FLOAT_VEC3, 4317 glu::TYPE_FLOAT_VEC4, 4318 glu::TYPE_INT_VEC2, 4319 glu::TYPE_INT_VEC3, 4320 glu::TYPE_INT_VEC4, 4321 glu::TYPE_UINT_VEC2, 4322 glu::TYPE_UINT_VEC3, 4323 glu::TYPE_UINT_VEC4, 4324 glu::TYPE_BOOL_VEC2, 4325 glu::TYPE_BOOL_VEC3, 4326 glu::TYPE_BOOL_VEC4, 4327 glu::TYPE_FLOAT_MAT2, 4328 glu::TYPE_FLOAT_MAT2X3, 4329 glu::TYPE_FLOAT_MAT2X4, 4330 glu::TYPE_FLOAT_MAT3X2, 4331 glu::TYPE_FLOAT_MAT3, 4332 glu::TYPE_FLOAT_MAT3X4, 4333 glu::TYPE_FLOAT_MAT4X2, 4334 glu::TYPE_FLOAT_MAT4X3, 4335 glu::TYPE_FLOAT_MAT4, 4336 4337 glu::TYPE_SAMPLER_2D, 4338 glu::TYPE_SAMPLER_CUBE, 4339 glu::TYPE_SAMPLER_2D_ARRAY, 4340 glu::TYPE_SAMPLER_3D, 4341 glu::TYPE_SAMPLER_2D_SHADOW, 4342 glu::TYPE_SAMPLER_CUBE_SHADOW, 4343 glu::TYPE_SAMPLER_2D_ARRAY_SHADOW, 4344 glu::TYPE_INT_SAMPLER_2D, 4345 glu::TYPE_INT_SAMPLER_CUBE, 4346 glu::TYPE_INT_SAMPLER_2D_ARRAY, 4347 glu::TYPE_INT_SAMPLER_3D, 4348 glu::TYPE_UINT_SAMPLER_2D, 4349 glu::TYPE_UINT_SAMPLER_CUBE, 4350 glu::TYPE_UINT_SAMPLER_2D_ARRAY, 4351 glu::TYPE_UINT_SAMPLER_3D, 4352 glu::TYPE_SAMPLER_2D_MULTISAMPLE, 4353 glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE, 4354 glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE, 4355 glu::TYPE_IMAGE_2D, 4356 glu::TYPE_IMAGE_CUBE, 4357 glu::TYPE_IMAGE_2D_ARRAY, 4358 glu::TYPE_IMAGE_3D, 4359 glu::TYPE_INT_IMAGE_2D, 4360 glu::TYPE_INT_IMAGE_CUBE, 4361 glu::TYPE_INT_IMAGE_2D_ARRAY, 4362 glu::TYPE_INT_IMAGE_3D, 4363 glu::TYPE_UINT_IMAGE_2D, 4364 glu::TYPE_UINT_IMAGE_CUBE, 4365 glu::TYPE_UINT_IMAGE_2D_ARRAY, 4366 glu::TYPE_UINT_IMAGE_3D, 4367 glu::TYPE_UINT_ATOMIC_COUNTER 4368 }; 4369 4370 for (;;) 4371 { 4372 const glu::DataType type = s_types[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_types)-1)]; 4373 4374 if (!excludeOpaqueTypes || 4375 glu::isDataTypeScalarOrVector(type) || 4376 glu::isDataTypeMatrix(type)) 4377 return type; 4378 } 4379 } 4380 4381 static ResourceDefinition::Node::SharedPtr generateRandomVariableDefinition (de::Random& rnd, 4382 const ResourceDefinition::Node::SharedPtr& parentStructure, 4383 glu::DataType baseType, 4384 const glu::Layout& layout, 4385 bool allowUnsized) 4386 { 4387 const int maxNesting = 4; 4388 ResourceDefinition::Node::SharedPtr currentStructure = parentStructure; 4389 const bool canBeInsideAStruct = layout.binding == -1 && !isDataTypeLayoutQualified(baseType); 4390 4391 for (int nestNdx = 0; nestNdx < maxNesting; ++nestNdx) 4392 { 4393 if (allowUnsized && nestNdx == 0 && rnd.getFloat() < 0.2) 4394 currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::ArrayElement(currentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 4395 else if (rnd.getFloat() < 0.3 && canBeInsideAStruct) 4396 currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StructMember(currentStructure)); 4397 else if (rnd.getFloat() < 0.3) 4398 currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::ArrayElement(currentStructure)); 4399 else 4400 break; 4401 } 4402 4403 return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Variable(currentStructure, baseType)); 4404 } 4405 4406 static ResourceDefinition::Node::SharedPtr generateRandomCoreShaderSet (de::Random& rnd) 4407 { 4408 if (rnd.getFloat() < 0.5f) 4409 { 4410 // compute only 4411 const ResourceDefinition::Node::SharedPtr program(new ResourceDefinition::Program()); 4412 return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES)); 4413 } 4414 else if (rnd.getFloat() < 0.5f) 4415 { 4416 // vertex and fragment 4417 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 4418 ResourceDefinition::ShaderSet* shaderSet = new ResourceDefinition::ShaderSet(program, glu::GLSL_VERSION_310_ES); 4419 4420 if (rnd.getBool()) 4421 { 4422 shaderSet->setStage(glu::SHADERTYPE_VERTEX, true); 4423 shaderSet->setStage(glu::SHADERTYPE_FRAGMENT, rnd.getBool()); 4424 } 4425 else 4426 { 4427 shaderSet->setStage(glu::SHADERTYPE_VERTEX, rnd.getBool()); 4428 shaderSet->setStage(glu::SHADERTYPE_FRAGMENT, true); 4429 } 4430 4431 return ResourceDefinition::Node::SharedPtr(shaderSet); 4432 } 4433 else 4434 { 4435 // separate vertex or fragment 4436 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true)); 4437 const glu::ShaderType shaderType = (rnd.getBool()) ? (glu::SHADERTYPE_VERTEX) : (glu::SHADERTYPE_FRAGMENT); 4438 4439 return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, shaderType, glu::GLSL_VERSION_310_ES)); 4440 } 4441 } 4442 4443 static ResourceDefinition::Node::SharedPtr generateRandomExtShaderSet (de::Random& rnd) 4444 { 4445 if (rnd.getFloat() < 0.5f) 4446 { 4447 // whole pipeline 4448 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 4449 ResourceDefinition::ShaderSet* shaderSet = new ResourceDefinition::ShaderSet(program, glu::GLSL_VERSION_310_ES); 4450 4451 shaderSet->setStage(glu::SHADERTYPE_VERTEX, rnd.getBool()); 4452 shaderSet->setStage(glu::SHADERTYPE_FRAGMENT, rnd.getBool()); 4453 4454 // tess shader are either both or neither present. Make cases interesting 4455 // by forcing one extended shader to always have reference 4456 if (rnd.getBool()) 4457 { 4458 shaderSet->setStage(glu::SHADERTYPE_GEOMETRY, true); 4459 4460 if (rnd.getBool()) 4461 { 4462 shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_CONTROL, rnd.getBool()); 4463 shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_EVALUATION, rnd.getBool()); 4464 } 4465 } 4466 else 4467 { 4468 shaderSet->setStage(glu::SHADERTYPE_GEOMETRY, rnd.getBool()); 4469 4470 if (rnd.getBool()) 4471 { 4472 shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_CONTROL, true); 4473 shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_EVALUATION, rnd.getBool()); 4474 } 4475 else 4476 { 4477 shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_CONTROL, rnd.getBool()); 4478 shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_EVALUATION, true); 4479 } 4480 } 4481 4482 return ResourceDefinition::Node::SharedPtr(shaderSet); 4483 } 4484 else 4485 { 4486 // separate 4487 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true)); 4488 const int selector = rnd.getInt(0, 2); 4489 const glu::ShaderType shaderType = (selector == 0) ? (glu::SHADERTYPE_GEOMETRY) 4490 : (selector == 1) ? (glu::SHADERTYPE_TESSELLATION_CONTROL) 4491 : (selector == 2) ? (glu::SHADERTYPE_TESSELLATION_EVALUATION) 4492 : (glu::SHADERTYPE_LAST); 4493 4494 return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, shaderType, glu::GLSL_VERSION_310_ES)); 4495 } 4496 } 4497 4498 static ResourceDefinition::Node::SharedPtr generateRandomShaderSet (de::Random& rnd, bool onlyExtensionStages) 4499 { 4500 if (!onlyExtensionStages) 4501 return generateRandomCoreShaderSet(rnd); 4502 else 4503 return generateRandomExtShaderSet(rnd); 4504 } 4505 4506 static glu::Layout generateRandomUniformBlockLayout (de::Random& rnd) 4507 { 4508 glu::Layout layout; 4509 4510 if (rnd.getBool()) 4511 layout.binding = rnd.getInt(0, 5); 4512 4513 if (rnd.getBool()) 4514 layout.matrixOrder = (rnd.getBool()) ? (glu::MATRIXORDER_COLUMN_MAJOR) : (glu::MATRIXORDER_ROW_MAJOR); 4515 4516 return layout; 4517 } 4518 4519 static glu::Layout generateRandomBufferBlockLayout (de::Random& rnd) 4520 { 4521 return generateRandomUniformBlockLayout(rnd); 4522 } 4523 4524 static glu::Layout generateRandomVariableLayout (de::Random& rnd, glu::DataType type, bool interfaceBlockMember) 4525 { 4526 glu::Layout layout; 4527 4528 if ((glu::isDataTypeAtomicCounter(type) || glu::isDataTypeImage(type) || glu::isDataTypeSampler(type)) && rnd.getBool()) 4529 layout.binding = rnd.getInt(0, 5); 4530 4531 if (glu::isDataTypeAtomicCounter(type) && rnd.getBool()) 4532 layout.offset = rnd.getInt(0, 3) * 4; 4533 4534 if (glu::isDataTypeMatrix(type) && interfaceBlockMember && rnd.getBool()) 4535 layout.matrixOrder = (rnd.getBool()) ? (glu::MATRIXORDER_COLUMN_MAJOR) : (glu::MATRIXORDER_ROW_MAJOR); 4536 4537 return layout; 4538 } 4539 4540 static void generateUniformRandomCase (Context& context, tcu::TestCaseGroup* const targetGroup, int index, bool onlyExtensionStages) 4541 { 4542 de::Random rnd (index * 0x12345); 4543 const ResourceDefinition::Node::SharedPtr shader = generateRandomShaderSet(rnd, onlyExtensionStages); 4544 const bool interfaceBlock = rnd.getBool(); 4545 const glu::DataType type = generateRandomDataType(rnd, interfaceBlock); 4546 const glu::Layout layout = generateRandomVariableLayout(rnd, type, interfaceBlock); 4547 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 4548 const ResourceDefinition::Node::SharedPtr uniform (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM)); 4549 ResourceDefinition::Node::SharedPtr currentStructure = uniform; 4550 4551 if (interfaceBlock) 4552 { 4553 const bool namedBlock = rnd.getBool(); 4554 4555 currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(currentStructure, generateRandomUniformBlockLayout(rnd))); 4556 4557 if (namedBlock && rnd.getBool()) 4558 currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::ArrayElement(currentStructure)); 4559 4560 currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::InterfaceBlock(currentStructure, namedBlock)); 4561 } 4562 4563 currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(currentStructure, layout)); 4564 currentStructure = generateRandomVariableDefinition(rnd, currentStructure, type, layout, false); 4565 4566 targetGroup->addChild(new ResourceTestCase(context, currentStructure, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_UNIFORM_INTERFACE_MASK), de::toString(index).c_str())); 4567 } 4568 4569 static void generateUniformCaseRandomCases (Context& context, tcu::TestCaseGroup* const targetGroup) 4570 { 4571 const int numBasicCases = 40; 4572 const int numTessGeoCases = 40; 4573 4574 for (int ndx = 0; ndx < numBasicCases; ++ndx) 4575 generateUniformRandomCase(context, targetGroup, ndx, false); 4576 for (int ndx = 0; ndx < numTessGeoCases; ++ndx) 4577 generateUniformRandomCase(context, targetGroup, numBasicCases + ndx, true); 4578 } 4579 4580 class UniformInterfaceTestGroup : public TestCaseGroup 4581 { 4582 public: 4583 UniformInterfaceTestGroup (Context& context); 4584 void init (void); 4585 }; 4586 4587 UniformInterfaceTestGroup::UniformInterfaceTestGroup (Context& context) 4588 : TestCaseGroup(context, "uniform", "Uniform interace") 4589 { 4590 } 4591 4592 void UniformInterfaceTestGroup::init (void) 4593 { 4594 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 4595 const ResourceDefinition::Node::SharedPtr computeShader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES)); 4596 4597 // .resource_list 4598 { 4599 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "resource_list", "Resource list"); 4600 addChild(blockGroup); 4601 generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformResourceListBlockContents); 4602 } 4603 4604 // .array_size 4605 { 4606 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "array_size", "Query array size"); 4607 addChild(blockGroup); 4608 generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformBlockArraySizeContents); 4609 } 4610 4611 // .array_stride 4612 { 4613 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "array_stride", "Query array stride"); 4614 addChild(blockGroup); 4615 generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformBlockArrayStrideContents); 4616 } 4617 4618 // .atomic_counter_buffer_index 4619 { 4620 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "atomic_counter_buffer_index", "Query atomic counter buffer index"); 4621 addChild(blockGroup); 4622 generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_DEFAULT | BLOCKFLAG_NAMED, generateUniformBlockAtomicCounterBufferIndexContents); 4623 } 4624 4625 // .block_index 4626 { 4627 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "block_index", "Query block index"); 4628 addChild(blockGroup); 4629 generateUniformBlockBlockIndexContents(m_context, blockGroup); 4630 } 4631 4632 // .location 4633 { 4634 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "location", "Query location"); 4635 addChild(blockGroup); 4636 generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_DEFAULT | BLOCKFLAG_NAMED | BLOCKFLAG_UNNAMED, generateUniformBlockLocationContents); 4637 } 4638 4639 // .matrix_row_major 4640 { 4641 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "matrix_row_major", "Query matrix row_major"); 4642 addChild(blockGroup); 4643 generateUniformMatrixCaseBlocks(m_context, computeShader, blockGroup, generateUniformMatrixOrderCaseBlockContentCases); 4644 } 4645 4646 // .matrix_stride 4647 { 4648 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "matrix_stride", "Query matrix stride"); 4649 addChild(blockGroup); 4650 generateUniformMatrixCaseBlocks(m_context, computeShader, blockGroup, generateUniformMatrixStrideCaseBlockContentCases); 4651 } 4652 4653 // .name_length 4654 { 4655 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "name_length", "Query name length"); 4656 addChild(blockGroup); 4657 generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformBlockNameLengthContents); 4658 } 4659 4660 // .offset 4661 { 4662 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "offset", "Query offset"); 4663 addChild(blockGroup); 4664 generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformBlockOffsetContents); 4665 } 4666 4667 // .referenced_by_shader 4668 { 4669 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "referenced_by_shader", "Query referenced by shader"); 4670 addChild(blockGroup); 4671 generateReferencedByShaderCaseBlocks(m_context, blockGroup, generateUniformReferencedByShaderSingleBlockContentCases); 4672 } 4673 4674 // .type 4675 { 4676 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "type", "Query type"); 4677 addChild(blockGroup); 4678 generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformBlockTypeContents); 4679 } 4680 4681 // .random 4682 { 4683 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "random", "Random"); 4684 addChild(blockGroup); 4685 generateUniformCaseRandomCases(m_context, blockGroup); 4686 } 4687 } 4688 4689 static void generateBufferBackedInterfaceResourceListCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, const char* blockName) 4690 { 4691 targetGroup->addChild(new ResourceListTestCase(context, targetResource, interface, blockName)); 4692 } 4693 4694 static void generateBufferBackedInterfaceNameLengthCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, const char* blockName) 4695 { 4696 targetGroup->addChild(new ResourceTestCase(context, targetResource, ProgramResourceQueryTestTarget(interface, PROGRAMRESOURCEPROP_NAME_LENGTH), blockName)); 4697 } 4698 4699 static void generateBufferBackedInterfaceResourceBasicBlockTypes (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup* const, ProgramInterface interface, const char* blockName)) 4700 { 4701 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 4702 const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES)); 4703 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 4704 const ResourceDefinition::Node::SharedPtr storageQualifier (new ResourceDefinition::StorageQualifier(defaultBlock, storage)); 4705 const ResourceDefinition::Node::SharedPtr binding (new ResourceDefinition::LayoutQualifier(storageQualifier, glu::Layout(-1, 1))); 4706 const ProgramInterface programInterface = (storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) : (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK); 4707 4708 // .named_block 4709 { 4710 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(binding, true)); 4711 const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3)); 4712 4713 blockContentGenerator(context, dummyVariable, targetGroup, programInterface, "named_block"); 4714 } 4715 4716 // .unnamed_block 4717 { 4718 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(binding, false)); 4719 const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3)); 4720 4721 blockContentGenerator(context, dummyVariable, targetGroup, programInterface, "unnamed_block"); 4722 } 4723 4724 // .block_array 4725 { 4726 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding, 3)); 4727 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true)); 4728 const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3)); 4729 4730 blockContentGenerator(context, dummyVariable, targetGroup, programInterface, "block_array"); 4731 } 4732 4733 // .block_array_single_element 4734 { 4735 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding, 1)); 4736 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true)); 4737 const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3)); 4738 4739 blockContentGenerator(context, dummyVariable, targetGroup, programInterface, "block_array_single_element"); 4740 } 4741 } 4742 4743 static void generateBufferBackedInterfaceResourceBufferBindingCases (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage) 4744 { 4745 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 4746 const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES)); 4747 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 4748 const ResourceDefinition::Node::SharedPtr storageQualifier (new ResourceDefinition::StorageQualifier(defaultBlock, storage)); 4749 4750 for (int ndx = 0; ndx < 2; ++ndx) 4751 { 4752 const bool explicitBinding = (ndx == 1); 4753 const int bindingNdx = (explicitBinding) ? (1) : (-1); 4754 const std::string nameSuffix = (explicitBinding) ? ("_explicit_binding") : (""); 4755 const ResourceDefinition::Node::SharedPtr binding (new ResourceDefinition::LayoutQualifier(storageQualifier, glu::Layout(-1, bindingNdx))); 4756 const ProgramInterface programInterface = (storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) : (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK); 4757 4758 // .named_block* 4759 { 4760 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(binding, true)); 4761 const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3)); 4762 4763 targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_BUFFER_BINDING), ("named_block" + nameSuffix).c_str())); 4764 } 4765 4766 // .unnamed_block* 4767 { 4768 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(binding, false)); 4769 const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3)); 4770 4771 targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_BUFFER_BINDING), ("unnamed_block" + nameSuffix).c_str())); 4772 } 4773 4774 // .block_array* 4775 { 4776 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding, 3)); 4777 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true)); 4778 const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3)); 4779 4780 targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_BUFFER_BINDING), ("block_array" + nameSuffix).c_str())); 4781 } 4782 } 4783 } 4784 4785 template <glu::Storage Storage> 4786 static void generateBufferBlockReferencedByShaderSingleBlockContentCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, int expandLevel) 4787 { 4788 const ProgramInterface programInterface = (Storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) : 4789 (Storage == glu::STORAGE_BUFFER) ? (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK) : 4790 (PROGRAMINTERFACE_LAST); 4791 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure)); 4792 const ResourceDefinition::Node::SharedPtr storage (new ResourceDefinition::StorageQualifier(defaultBlock, Storage)); 4793 4794 DE_UNREF(expandLevel); 4795 4796 DE_ASSERT(programInterface != PROGRAMINTERFACE_LAST); 4797 4798 // .named_block 4799 { 4800 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(storage, true)); 4801 const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3)); 4802 4803 targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_REFERENCED_BY_SHADER), "named_block")); 4804 } 4805 4806 // .unnamed_block 4807 { 4808 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(storage, false)); 4809 const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3)); 4810 4811 targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_REFERENCED_BY_SHADER), "unnamed_block")); 4812 } 4813 4814 // .block_array 4815 { 4816 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(storage, 3)); 4817 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true)); 4818 const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3)); 4819 4820 targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_REFERENCED_BY_SHADER), "block_array")); 4821 } 4822 } 4823 4824 static void generateBufferBackedInterfaceResourceActiveVariablesCase (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage) 4825 { 4826 targetGroup->addChild(new InterfaceBlockActiveVariablesTestCase(context, "named_block", "Named block", storage, InterfaceBlockActiveVariablesTestCase::CASE_NAMED_BLOCK)); 4827 targetGroup->addChild(new InterfaceBlockActiveVariablesTestCase(context, "unnamed_block", "Unnamed block", storage, InterfaceBlockActiveVariablesTestCase::CASE_UNNAMED_BLOCK)); 4828 targetGroup->addChild(new InterfaceBlockActiveVariablesTestCase(context, "block_array", "Block array", storage, InterfaceBlockActiveVariablesTestCase::CASE_BLOCK_ARRAY)); 4829 } 4830 4831 static void generateBufferBackedInterfaceResourceBufferDataSizeCases (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage) 4832 { 4833 targetGroup->addChild(new InterfaceBlockDataSizeTestCase(context, "named_block", "Named block", storage, InterfaceBlockDataSizeTestCase::CASE_NAMED_BLOCK)); 4834 targetGroup->addChild(new InterfaceBlockDataSizeTestCase(context, "unnamed_block", "Unnamed block", storage, InterfaceBlockDataSizeTestCase::CASE_UNNAMED_BLOCK)); 4835 targetGroup->addChild(new InterfaceBlockDataSizeTestCase(context, "block_array", "Block array", storage, InterfaceBlockDataSizeTestCase::CASE_BLOCK_ARRAY)); 4836 } 4837 4838 class BufferBackedBlockInterfaceTestGroup : public TestCaseGroup 4839 { 4840 public: 4841 BufferBackedBlockInterfaceTestGroup (Context& context, glu::Storage interfaceBlockStorage); 4842 void init (void); 4843 4844 private: 4845 static const char* getGroupName (glu::Storage storage); 4846 static const char* getGroupDescription (glu::Storage storage); 4847 4848 const glu::Storage m_storage; 4849 }; 4850 4851 BufferBackedBlockInterfaceTestGroup::BufferBackedBlockInterfaceTestGroup(Context& context, glu::Storage storage) 4852 : TestCaseGroup (context, getGroupName(storage), getGroupDescription(storage)) 4853 , m_storage (storage) 4854 { 4855 DE_ASSERT(storage == glu::STORAGE_BUFFER || storage == glu::STORAGE_UNIFORM); 4856 } 4857 4858 void BufferBackedBlockInterfaceTestGroup::init (void) 4859 { 4860 // .resource_list 4861 { 4862 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "resource_list", "Resource list"); 4863 addChild(blockGroup); 4864 generateBufferBackedInterfaceResourceBasicBlockTypes(m_context, blockGroup, m_storage, generateBufferBackedInterfaceResourceListCase); 4865 } 4866 4867 // .active_variables 4868 { 4869 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "active_variables", "Active variables"); 4870 addChild(blockGroup); 4871 generateBufferBackedInterfaceResourceActiveVariablesCase(m_context, blockGroup, m_storage); 4872 } 4873 4874 // .buffer_binding 4875 { 4876 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "buffer_binding", "Buffer binding"); 4877 addChild(blockGroup); 4878 generateBufferBackedInterfaceResourceBufferBindingCases(m_context, blockGroup, m_storage); 4879 } 4880 4881 // .buffer_data_size 4882 { 4883 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "buffer_data_size", "Buffer data size"); 4884 addChild(blockGroup); 4885 generateBufferBackedInterfaceResourceBufferDataSizeCases(m_context, blockGroup, m_storage); 4886 } 4887 4888 // .name_length 4889 { 4890 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "name_length", "Name length"); 4891 addChild(blockGroup); 4892 generateBufferBackedInterfaceResourceBasicBlockTypes(m_context, blockGroup, m_storage, generateBufferBackedInterfaceNameLengthCase); 4893 } 4894 4895 // .referenced_by 4896 { 4897 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "referenced_by", "Referenced by shader"); 4898 addChild(blockGroup); 4899 4900 if (m_storage == glu::STORAGE_UNIFORM) 4901 generateReferencedByShaderCaseBlocks(m_context, blockGroup, generateBufferBlockReferencedByShaderSingleBlockContentCases<glu::STORAGE_UNIFORM>); 4902 else if (m_storage == glu::STORAGE_BUFFER) 4903 generateReferencedByShaderCaseBlocks(m_context, blockGroup, generateBufferBlockReferencedByShaderSingleBlockContentCases<glu::STORAGE_BUFFER>); 4904 else 4905 DE_ASSERT(false); 4906 } 4907 } 4908 4909 const char* BufferBackedBlockInterfaceTestGroup::getGroupName (glu::Storage storage) 4910 { 4911 switch (storage) 4912 { 4913 case glu::STORAGE_UNIFORM: return "uniform_block"; 4914 case glu::STORAGE_BUFFER: return "shader_storage_block"; 4915 default: 4916 DE_ASSERT("false"); 4917 return DE_NULL; 4918 } 4919 } 4920 4921 const char* BufferBackedBlockInterfaceTestGroup::getGroupDescription (glu::Storage storage) 4922 { 4923 switch (storage) 4924 { 4925 case glu::STORAGE_UNIFORM: return "Uniform block interface"; 4926 case glu::STORAGE_BUFFER: return "Shader storage block interface"; 4927 default: 4928 DE_ASSERT("false"); 4929 return DE_NULL; 4930 } 4931 } 4932 4933 class AtomicCounterTestGroup : public TestCaseGroup 4934 { 4935 public: 4936 AtomicCounterTestGroup (Context& context); 4937 void init (void); 4938 }; 4939 4940 AtomicCounterTestGroup::AtomicCounterTestGroup (Context& context) 4941 : TestCaseGroup(context, "atomic_counter_buffer", "Atomic counter buffer") 4942 { 4943 } 4944 4945 void AtomicCounterTestGroup::init (void) 4946 { 4947 static const struct 4948 { 4949 const char* name; 4950 deUint32 flags; 4951 } pipelines[] = 4952 { 4953 { 4954 "vertex_fragment", 4955 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) 4956 }, 4957 { 4958 "vertex_tess_fragment", 4959 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION) 4960 }, 4961 { 4962 "vertex_geo_fragment", 4963 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_GEOMETRY) 4964 }, 4965 { 4966 "vertex_tess_geo_fragment", 4967 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION) | (1 << glu::SHADERTYPE_GEOMETRY), 4968 }, 4969 }; 4970 4971 // .resource_list 4972 addChild(new AtomicCounterResourceListCase(m_context, "resource_list", "Resource list")); 4973 4974 // .active_variables 4975 addChild(new AtomicCounterActiveVariablesCase(m_context, "active_variables", "Active variables")); 4976 4977 // .buffer_binding 4978 addChild(new AtomicCounterBufferBindingCase(m_context, "buffer_binding", "Buffer binding")); 4979 4980 // .buffer_data_size 4981 addChild(new AtomicCounterBufferDataSizeCase(m_context, "buffer_data_size", "Buffer binding")); 4982 4983 // .referenced_by 4984 addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_compute", "", false, (1 << glu::SHADERTYPE_COMPUTE), (1 << glu::SHADERTYPE_COMPUTE))); 4985 addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_vertex", "", true, (1 << glu::SHADERTYPE_VERTEX), (1 << glu::SHADERTYPE_VERTEX))); 4986 addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_fragment", "", true, (1 << glu::SHADERTYPE_FRAGMENT), (1 << glu::SHADERTYPE_FRAGMENT))); 4987 addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_geometry", "", true, (1 << glu::SHADERTYPE_GEOMETRY), (1 << glu::SHADERTYPE_GEOMETRY))); 4988 addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_tess_ctrl", "", true, (1 << glu::SHADERTYPE_TESSELLATION_CONTROL), (1 << glu::SHADERTYPE_TESSELLATION_CONTROL))); 4989 addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_tess_eval", "", true, (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION), (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION))); 4990 4991 for (int pipelineNdx = 0; pipelineNdx < DE_LENGTH_OF_ARRAY(pipelines); ++pipelineNdx) 4992 { 4993 addChild(new AtomicCounterReferencedByCase(m_context, (std::string() + "referenced_by_" + pipelines[pipelineNdx].name).c_str(), "", false, pipelines[pipelineNdx].flags, pipelines[pipelineNdx].flags)); 4994 4995 for (deUint32 stageNdx = 0; stageNdx < glu::SHADERTYPE_LAST; ++stageNdx) 4996 { 4997 const deUint32 currentBit = (1u << stageNdx); 4998 if (currentBit > pipelines[pipelineNdx].flags) 4999 break; 5000 if (currentBit & pipelines[pipelineNdx].flags) 5001 { 5002 const char* stageName = (stageNdx == glu::SHADERTYPE_VERTEX) ? ("vertex") 5003 : (stageNdx == glu::SHADERTYPE_FRAGMENT) ? ("fragment") 5004 : (stageNdx == glu::SHADERTYPE_GEOMETRY) ? ("geo") 5005 : (stageNdx == glu::SHADERTYPE_TESSELLATION_CONTROL) ? ("tess_ctrl") 5006 : (stageNdx == glu::SHADERTYPE_TESSELLATION_EVALUATION) ? ("tess_eval") 5007 : (DE_NULL); 5008 const std::string name = std::string() + "referenced_by_" + pipelines[pipelineNdx].name + "_only_" + stageName; 5009 5010 addChild(new AtomicCounterReferencedByCase(m_context, name.c_str(), "", false, pipelines[pipelineNdx].flags, currentBit)); 5011 } 5012 } 5013 } 5014 } 5015 5016 static void generateProgramInputOutputShaderCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, bool withCompute, bool inputCase, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, deUint32)) 5017 { 5018 static const struct 5019 { 5020 const char* name; 5021 glu::ShaderType stage; 5022 } singleStageCases[] = 5023 { 5024 { "separable_vertex", glu::SHADERTYPE_VERTEX }, 5025 { "separable_fragment", glu::SHADERTYPE_FRAGMENT }, 5026 { "separable_tess_ctrl", glu::SHADERTYPE_TESSELLATION_CONTROL }, 5027 { "separable_tess_eval", glu::SHADERTYPE_TESSELLATION_EVALUATION }, 5028 { "separable_geometry", glu::SHADERTYPE_GEOMETRY }, 5029 }; 5030 5031 // .vertex_fragment 5032 { 5033 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "vertex_fragment", "Vertex and fragment"); 5034 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(false)); 5035 ResourceDefinition::ShaderSet* shaderSetPtr = new ResourceDefinition::ShaderSet(program, glu::GLSL_VERSION_310_ES); 5036 const ResourceDefinition::Node::SharedPtr shaderSet (shaderSetPtr); 5037 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shaderSet)); 5038 5039 shaderSetPtr->setStage(glu::SHADERTYPE_VERTEX, inputCase); 5040 shaderSetPtr->setStage(glu::SHADERTYPE_FRAGMENT, !inputCase); 5041 5042 targetGroup->addChild(blockGroup); 5043 5044 blockContentGenerator(context, defaultBlock, blockGroup, (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT)); 5045 } 5046 5047 // .separable_* 5048 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(singleStageCases); ++ndx) 5049 { 5050 TestCaseGroup* const blockGroup = new TestCaseGroup(context, singleStageCases[ndx].name, ""); 5051 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true)); 5052 const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glu::GLSL_VERSION_310_ES)); 5053 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 5054 5055 targetGroup->addChild(blockGroup); 5056 blockContentGenerator(context, defaultBlock, blockGroup, (1 << singleStageCases[ndx].stage)); 5057 } 5058 5059 // .compute 5060 if (withCompute) 5061 { 5062 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "compute", "Compute"); 5063 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true)); 5064 const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES)); 5065 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 5066 5067 targetGroup->addChild(blockGroup); 5068 5069 blockContentGenerator(context, defaultBlock, blockGroup, (1 << glu::SHADERTYPE_COMPUTE)); 5070 } 5071 5072 // .interface_blocks 5073 { 5074 static const struct 5075 { 5076 const char* inputName; 5077 glu::ShaderType inputStage; 5078 glu::Storage inputStorage; 5079 const char* outputName; 5080 glu::ShaderType outputStage; 5081 glu::Storage outputStorage; 5082 } ioBlockTypes[] = 5083 { 5084 { 5085 "in", 5086 glu::SHADERTYPE_FRAGMENT, 5087 glu::STORAGE_IN, 5088 "out", 5089 glu::SHADERTYPE_VERTEX, 5090 glu::STORAGE_OUT, 5091 }, 5092 { 5093 "patch_in", 5094 glu::SHADERTYPE_TESSELLATION_EVALUATION, 5095 glu::STORAGE_PATCH_IN, 5096 "patch_out", 5097 glu::SHADERTYPE_TESSELLATION_CONTROL, 5098 glu::STORAGE_PATCH_OUT, 5099 }, 5100 }; 5101 5102 tcu::TestCaseGroup* const ioBlocksGroup = new TestCaseGroup(context, "interface_blocks", "Interface blocks"); 5103 targetGroup->addChild(ioBlocksGroup); 5104 5105 // .in/out 5106 // .sample in/out 5107 // .patch in/out 5108 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(ioBlockTypes); ++ndx) 5109 { 5110 const char* const name = (inputCase) ? (ioBlockTypes[ndx].inputName) : (ioBlockTypes[ndx].outputName); 5111 const glu::ShaderType shaderType = (inputCase) ? (ioBlockTypes[ndx].inputStage) : (ioBlockTypes[ndx].outputStage); 5112 const glu::Storage storageType = (inputCase) ? (ioBlockTypes[ndx].inputStorage) : (ioBlockTypes[ndx].outputStorage); 5113 tcu::TestCaseGroup* const ioBlockGroup = new TestCaseGroup(context, name, ""); 5114 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true)); 5115 const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, shaderType, glu::GLSL_VERSION_310_ES)); 5116 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 5117 const ResourceDefinition::Node::SharedPtr storage (new ResourceDefinition::StorageQualifier(defaultBlock, storageType)); 5118 5119 ioBlocksGroup->addChild(ioBlockGroup); 5120 5121 // .named_block 5122 { 5123 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(storage, true)); 5124 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "named_block", "Named block"); 5125 5126 ioBlockGroup->addChild(blockGroup); 5127 5128 blockContentGenerator(context, block, blockGroup, (1 << shaderType)); 5129 } 5130 5131 // .named_block_explicit_location 5132 { 5133 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(storage, glu::Layout(3))); 5134 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(layout, true)); 5135 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "named_block_explicit_location", "Named block with explicit location"); 5136 5137 ioBlockGroup->addChild(blockGroup); 5138 5139 blockContentGenerator(context, block, blockGroup, (1 << shaderType)); 5140 } 5141 5142 // .unnamed_block 5143 { 5144 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(storage, false)); 5145 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unnamed_block", "Unnamed block"); 5146 5147 ioBlockGroup->addChild(blockGroup); 5148 5149 blockContentGenerator(context, block, blockGroup, (1 << shaderType)); 5150 } 5151 5152 // .block_array 5153 { 5154 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(storage)); 5155 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true)); 5156 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "block_array", "Block array"); 5157 5158 ioBlockGroup->addChild(blockGroup); 5159 5160 blockContentGenerator(context, block, blockGroup, (1 << shaderType)); 5161 } 5162 } 5163 } 5164 } 5165 5166 static void generateProgramInputBlockContents (Context& context, 5167 const ResourceDefinition::Node::SharedPtr& parentStructure, 5168 tcu::TestCaseGroup* targetGroup, 5169 deUint32 presentShadersMask, 5170 bool includeEmpty, 5171 void (*genCase)(Context& context, 5172 const ResourceDefinition::Node::SharedPtr& parentStructure, 5173 tcu::TestCaseGroup* targetGroup, 5174 ProgramInterface interface, 5175 const char* name)) 5176 { 5177 const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK; 5178 const ResourceDefinition::Node::SharedPtr input = (inDefaultBlock) 5179 ? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_IN))) 5180 : (parentStructure); 5181 const glu::ShaderType firstStage = getShaderMaskFirstStage(presentShadersMask); 5182 5183 // .empty 5184 if (includeEmpty && inDefaultBlock) 5185 genCase(context, parentStructure, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "empty"); 5186 5187 if (firstStage == glu::SHADERTYPE_VERTEX) 5188 { 5189 // .var 5190 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4)); 5191 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var"); 5192 } 5193 else if (firstStage == glu::SHADERTYPE_FRAGMENT || !inDefaultBlock) 5194 { 5195 // .var 5196 { 5197 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4)); 5198 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var"); 5199 } 5200 // .var_struct 5201 { 5202 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(input)); 5203 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5204 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var_struct"); 5205 } 5206 // .var_array 5207 { 5208 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input)); 5209 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5210 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var_array"); 5211 } 5212 } 5213 else if (firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL || 5214 firstStage == glu::SHADERTYPE_GEOMETRY) 5215 { 5216 // arrayed interface 5217 5218 // .var 5219 { 5220 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5221 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5222 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var"); 5223 } 5224 // extension forbids use arrays of structs 5225 // extension forbids use arrays of arrays 5226 } 5227 else if (firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION) 5228 { 5229 // arrayed interface 5230 const ResourceDefinition::Node::SharedPtr patchInput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_IN)); 5231 5232 // .var 5233 { 5234 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5235 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5236 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var"); 5237 } 5238 // extension forbids use arrays of structs 5239 // extension forbids use arrays of arrays 5240 5241 // .patch_var 5242 { 5243 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(patchInput, glu::TYPE_FLOAT_VEC4)); 5244 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "patch_var"); 5245 } 5246 // .patch_var_struct 5247 { 5248 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchInput)); 5249 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5250 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "patch_var_struct"); 5251 } 5252 // .patch_var_array 5253 { 5254 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchInput)); 5255 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5256 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "patch_var_array"); 5257 } 5258 } 5259 else if (firstStage == glu::SHADERTYPE_COMPUTE) 5260 { 5261 // nada 5262 } 5263 else 5264 DE_ASSERT(false); 5265 } 5266 5267 static void generateProgramOutputBlockContents (Context& context, 5268 const ResourceDefinition::Node::SharedPtr& parentStructure, 5269 tcu::TestCaseGroup* targetGroup, 5270 deUint32 presentShadersMask, 5271 bool includeEmpty, 5272 void (*genCase)(Context& context, 5273 const ResourceDefinition::Node::SharedPtr& parentStructure, 5274 tcu::TestCaseGroup* targetGroup, 5275 ProgramInterface interface, 5276 const char* name)) 5277 { 5278 const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK; 5279 const ResourceDefinition::Node::SharedPtr output = (inDefaultBlock) 5280 ? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_OUT))) 5281 : (parentStructure); 5282 const glu::ShaderType lastStage = getShaderMaskLastStage(presentShadersMask); 5283 5284 // .empty 5285 if (includeEmpty && inDefaultBlock) 5286 genCase(context, parentStructure, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "empty"); 5287 5288 if (lastStage == glu::SHADERTYPE_VERTEX || 5289 lastStage == glu::SHADERTYPE_GEOMETRY || 5290 lastStage == glu::SHADERTYPE_TESSELLATION_EVALUATION || 5291 !inDefaultBlock) 5292 { 5293 // .var 5294 { 5295 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4)); 5296 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var"); 5297 } 5298 // .var_struct 5299 { 5300 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(output)); 5301 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5302 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var_struct"); 5303 } 5304 // .var_array 5305 { 5306 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output)); 5307 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5308 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var_array"); 5309 } 5310 } 5311 else if (lastStage == glu::SHADERTYPE_FRAGMENT) 5312 { 5313 // .var 5314 { 5315 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4)); 5316 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var"); 5317 } 5318 // .var_array 5319 { 5320 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output)); 5321 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5322 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var_array"); 5323 } 5324 } 5325 else if (lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL) 5326 { 5327 // arrayed interface 5328 const ResourceDefinition::Node::SharedPtr patchOutput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_OUT)); 5329 5330 // .var 5331 { 5332 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5333 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5334 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var"); 5335 } 5336 // extension forbids use arrays of structs 5337 // extension forbids use array of arrays 5338 5339 // .patch_var 5340 { 5341 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(patchOutput, glu::TYPE_FLOAT_VEC4)); 5342 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "patch_var"); 5343 } 5344 // .patch_var_struct 5345 { 5346 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchOutput)); 5347 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5348 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "patch_var_struct"); 5349 } 5350 // .patch_var_array 5351 { 5352 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchOutput)); 5353 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5354 genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "patch_var_array"); 5355 } 5356 } 5357 else if (lastStage == glu::SHADERTYPE_COMPUTE) 5358 { 5359 // nada 5360 } 5361 else 5362 DE_ASSERT(false); 5363 } 5364 5365 static void addProgramInputOutputResourceListCase (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, ProgramInterface programInterface, const char* name) 5366 { 5367 ResourceListTestCase* const resourceListCase = new ResourceListTestCase(context, parentStructure, programInterface); 5368 5369 DE_ASSERT(deStringEqual(name, resourceListCase->getName())); 5370 DE_UNREF(name); 5371 targetGroup->addChild(resourceListCase); 5372 } 5373 5374 static void generateProgramInputResourceListBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask) 5375 { 5376 generateProgramInputBlockContents(context, parentStructure, targetGroup, presentShadersMask, true, addProgramInputOutputResourceListCase); 5377 } 5378 5379 static void generateProgramOutputResourceListBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask) 5380 { 5381 generateProgramOutputBlockContents(context, parentStructure, targetGroup, presentShadersMask, true, addProgramInputOutputResourceListCase); 5382 } 5383 5384 template <ProgramResourcePropFlags TargetProp> 5385 static void addProgramInputOutputResourceTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, ProgramInterface programInterface, const char* name) 5386 { 5387 ResourceTestCase* const resourceTestCase = new ResourceTestCase(context, parentStructure, ProgramResourceQueryTestTarget(programInterface, TargetProp), name); 5388 targetGroup->addChild(resourceTestCase); 5389 } 5390 5391 template <ProgramResourcePropFlags TargetProp> 5392 static void generateProgramInputBasicBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask) 5393 { 5394 generateProgramInputBlockContents(context, parentStructure, targetGroup, presentShadersMask, false, addProgramInputOutputResourceTestCase<TargetProp>); 5395 } 5396 5397 template <ProgramResourcePropFlags TargetProp> 5398 static void generateProgramOutputBasicBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask) 5399 { 5400 generateProgramOutputBlockContents(context, parentStructure, targetGroup, presentShadersMask, false, addProgramInputOutputResourceTestCase<TargetProp>); 5401 } 5402 5403 static void generateProgramInputLocationBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask) 5404 { 5405 const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK; 5406 const ResourceDefinition::Node::SharedPtr input = (inDefaultBlock) 5407 ? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_IN))) 5408 : (parentStructure); 5409 const glu::ShaderType firstStage = getShaderMaskFirstStage(presentShadersMask); 5410 5411 if (firstStage == glu::SHADERTYPE_VERTEX) 5412 { 5413 // .var 5414 { 5415 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4)); 5416 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var")); 5417 } 5418 // .var_explicit_location 5419 { 5420 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2))); 5421 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4)); 5422 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location")); 5423 } 5424 } 5425 else if (firstStage == glu::SHADERTYPE_FRAGMENT || !inDefaultBlock) 5426 { 5427 // .var 5428 { 5429 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4)); 5430 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var")); 5431 } 5432 // .var_explicit_location 5433 { 5434 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2))); 5435 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4)); 5436 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location")); 5437 } 5438 // .var_struct 5439 { 5440 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(input)); 5441 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5442 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_struct")); 5443 } 5444 // .var_struct_explicit_location 5445 { 5446 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2))); 5447 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(layout)); 5448 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5449 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_struct_explicit_location")); 5450 } 5451 // .var_array 5452 { 5453 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input)); 5454 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5455 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array")); 5456 } 5457 // .var_array_explicit_location 5458 { 5459 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2))); 5460 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout)); 5461 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5462 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array_explicit_location")); 5463 } 5464 } 5465 else if (firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL || 5466 firstStage == glu::SHADERTYPE_GEOMETRY) 5467 { 5468 // arrayed interface 5469 5470 // .var 5471 { 5472 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5473 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5474 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var")); 5475 } 5476 // .var_explicit_location 5477 { 5478 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2))); 5479 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5480 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5481 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location")); 5482 } 5483 // extension forbids use arrays of structs 5484 // extension forbids use arrays of arrays 5485 } 5486 else if (firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION) 5487 { 5488 // arrayed interface 5489 const ResourceDefinition::Node::SharedPtr patchInput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_IN)); 5490 5491 // .var 5492 { 5493 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5494 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5495 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var")); 5496 } 5497 // .var_explicit_location 5498 { 5499 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2))); 5500 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5501 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5502 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location")); 5503 } 5504 // extension forbids use arrays of structs 5505 // extension forbids use arrays of arrays 5506 5507 // .patch_var 5508 { 5509 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(patchInput, glu::TYPE_FLOAT_VEC4)); 5510 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var")); 5511 } 5512 // .patch_var_explicit_location 5513 { 5514 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchInput, glu::Layout(2))); 5515 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4)); 5516 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_explicit_location")); 5517 } 5518 // .patch_var_struct 5519 { 5520 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchInput)); 5521 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5522 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_struct")); 5523 } 5524 // .patch_var_struct_explicit_location 5525 { 5526 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchInput, glu::Layout(2))); 5527 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(layout)); 5528 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5529 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_struct_explicit_location")); 5530 } 5531 // .patch_var_array 5532 { 5533 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchInput)); 5534 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5535 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_array")); 5536 } 5537 // .patch_var_array_explicit_location 5538 { 5539 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchInput, glu::Layout(2))); 5540 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout)); 5541 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5542 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_array_explicit_location")); 5543 } 5544 } 5545 else if (firstStage == glu::SHADERTYPE_COMPUTE) 5546 { 5547 // nada 5548 } 5549 else 5550 DE_ASSERT(false); 5551 } 5552 5553 static void generateProgramOutputLocationBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask) 5554 { 5555 const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK; 5556 const ResourceDefinition::Node::SharedPtr output = (inDefaultBlock) 5557 ? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_OUT))) 5558 : (parentStructure); 5559 const glu::ShaderType lastStage = getShaderMaskLastStage(presentShadersMask); 5560 5561 if (lastStage == glu::SHADERTYPE_VERTEX || 5562 lastStage == glu::SHADERTYPE_GEOMETRY || 5563 lastStage == glu::SHADERTYPE_TESSELLATION_EVALUATION || 5564 !inDefaultBlock) 5565 { 5566 // .var 5567 { 5568 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4)); 5569 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var")); 5570 } 5571 // .var_explicit_location 5572 { 5573 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(2))); 5574 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4)); 5575 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location")); 5576 } 5577 // .var_struct 5578 { 5579 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(output)); 5580 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5581 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_struct")); 5582 } 5583 // .var_struct_explicit_location 5584 { 5585 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(2))); 5586 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(layout)); 5587 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5588 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_struct_explicit_location")); 5589 } 5590 // .var_array 5591 { 5592 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output)); 5593 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5594 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array")); 5595 } 5596 // .var_array_explicit_location 5597 { 5598 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(2))); 5599 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout)); 5600 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5601 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array_explicit_location")); 5602 } 5603 } 5604 else if (lastStage == glu::SHADERTYPE_FRAGMENT) 5605 { 5606 // .var 5607 { 5608 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4)); 5609 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var")); 5610 } 5611 // .var_explicit_location 5612 { 5613 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(2))); 5614 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4)); 5615 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location")); 5616 } 5617 // .var_array 5618 { 5619 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output)); 5620 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5621 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array")); 5622 } 5623 // .var_array_explicit_location 5624 { 5625 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(1))); 5626 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout)); 5627 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5628 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array_explicit_location")); 5629 } 5630 } 5631 else if (lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL) 5632 { 5633 // arrayed interface 5634 const ResourceDefinition::Node::SharedPtr patchOutput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_OUT)); 5635 5636 // .var 5637 { 5638 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5639 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5640 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var")); 5641 } 5642 // .var_explicit_location 5643 { 5644 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(2))); 5645 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5646 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5647 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location")); 5648 } 5649 // extension forbids use arrays of structs 5650 // extension forbids use array of arrays 5651 5652 // .patch_var 5653 { 5654 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(patchOutput, glu::TYPE_FLOAT_VEC4)); 5655 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var")); 5656 } 5657 // .patch_var_explicit_location 5658 { 5659 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchOutput, glu::Layout(2))); 5660 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4)); 5661 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_explicit_location")); 5662 } 5663 // .patch_var_struct 5664 { 5665 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchOutput)); 5666 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5667 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_struct")); 5668 } 5669 // .patch_var_struct_explicit_location 5670 { 5671 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchOutput, glu::Layout(2))); 5672 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(layout)); 5673 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4)); 5674 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_struct_explicit_location")); 5675 } 5676 // .patch_var_array 5677 { 5678 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchOutput)); 5679 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5680 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_array")); 5681 } 5682 // .patch_var_array_explicit_location 5683 { 5684 const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchOutput, glu::Layout(2))); 5685 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout)); 5686 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 5687 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_array_explicit_location")); 5688 } 5689 } 5690 else if (lastStage == glu::SHADERTYPE_COMPUTE) 5691 { 5692 // nada 5693 } 5694 else 5695 DE_ASSERT(false); 5696 } 5697 5698 static void generateProgramInputOutputReferencedByCases (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage) 5699 { 5700 // all whole pipelines 5701 targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_vertex_fragment", "", storage, ProgramInputOutputReferencedByCase::CASE_VERTEX_FRAGMENT)); 5702 targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_vertex_tess_fragment", "", storage, ProgramInputOutputReferencedByCase::CASE_VERTEX_TESS_FRAGMENT)); 5703 targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_vertex_geo_fragment", "", storage, ProgramInputOutputReferencedByCase::CASE_VERTEX_GEO_FRAGMENT)); 5704 targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_vertex_tess_geo_fragment", "", storage, ProgramInputOutputReferencedByCase::CASE_VERTEX_TESS_GEO_FRAGMENT)); 5705 5706 // all partial pipelines 5707 targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_vertex", "", storage, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_VERTEX)); 5708 targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_fragment", "", storage, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_FRAGMENT)); 5709 targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_geometry", "", storage, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_GEOMETRY)); 5710 targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_tess_eval", "", storage, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_TESS_EVAL)); 5711 targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_tess_ctrl", "", storage, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_TESS_CTRL)); 5712 5713 // patch 5714 if (storage == glu::STORAGE_IN) 5715 targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_tess_eval_patch_in", "", glu::STORAGE_PATCH_IN, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_TESS_EVAL)); 5716 else if (storage == glu::STORAGE_OUT) 5717 targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_tess_ctrl_patch_out", "", glu::STORAGE_PATCH_OUT, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_TESS_CTRL)); 5718 else 5719 DE_ASSERT(false); 5720 } 5721 5722 template <ProgramInterface interface> 5723 static void generateProgramInputOutputTypeBasicTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool allowMatrixCases, int expandLevel) 5724 { 5725 static const struct 5726 { 5727 glu::DataType type; 5728 bool isMatrix; 5729 int level; 5730 } variableTypes[] = 5731 { 5732 { glu::TYPE_FLOAT, false, 0 }, 5733 { glu::TYPE_INT, false, 1 }, 5734 { glu::TYPE_UINT, false, 1 }, 5735 { glu::TYPE_FLOAT_VEC2, false, 2 }, 5736 { glu::TYPE_FLOAT_VEC3, false, 1 }, 5737 { glu::TYPE_FLOAT_VEC4, false, 2 }, 5738 { glu::TYPE_INT_VEC2, false, 0 }, 5739 { glu::TYPE_INT_VEC3, false, 2 }, 5740 { glu::TYPE_INT_VEC4, false, 2 }, 5741 { glu::TYPE_UINT_VEC2, false, 2 }, 5742 { glu::TYPE_UINT_VEC3, false, 2 }, 5743 { glu::TYPE_UINT_VEC4, false, 0 }, 5744 { glu::TYPE_FLOAT_MAT2, true, 2 }, 5745 { glu::TYPE_FLOAT_MAT2X3, true, 2 }, 5746 { glu::TYPE_FLOAT_MAT2X4, true, 2 }, 5747 { glu::TYPE_FLOAT_MAT3X2, true, 0 }, 5748 { glu::TYPE_FLOAT_MAT3, true, 2 }, 5749 { glu::TYPE_FLOAT_MAT3X4, true, 2 }, 5750 { glu::TYPE_FLOAT_MAT4X2, true, 2 }, 5751 { glu::TYPE_FLOAT_MAT4X3, true, 2 }, 5752 { glu::TYPE_FLOAT_MAT4, true, 2 }, 5753 }; 5754 5755 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx) 5756 { 5757 if (!allowMatrixCases && variableTypes[ndx].isMatrix) 5758 continue; 5759 5760 if (variableTypes[ndx].level <= expandLevel) 5761 { 5762 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].type)); 5763 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(interface, PROGRAMRESOURCEPROP_TYPE))); 5764 } 5765 } 5766 } 5767 5768 static void generateProgramInputTypeBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask) 5769 { 5770 const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK; 5771 const ResourceDefinition::Node::SharedPtr input = (inDefaultBlock) 5772 ? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_IN))) 5773 : (parentStructure); 5774 const glu::ShaderType firstStage = getShaderMaskFirstStage(presentShadersMask); 5775 const int interfaceBlockExpansionReducement = (!inDefaultBlock) ? (1) : (0); // lesser expansions on block members to keep test counts reasonable 5776 5777 if (firstStage == glu::SHADERTYPE_VERTEX) 5778 { 5779 // Only basic types (and no booleans) 5780 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, input, targetGroup, true, 2 - interfaceBlockExpansionReducement); 5781 } 5782 else if (firstStage == glu::SHADERTYPE_FRAGMENT || !inDefaultBlock) 5783 { 5784 const ResourceDefinition::Node::SharedPtr flatShading(new ResourceDefinition::InterpolationQualifier(input, glu::INTERPOLATION_FLAT)); 5785 5786 // Only basic types, arrays of basic types, struct of basic types (and no booleans) 5787 { 5788 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types"); 5789 targetGroup->addChild(blockGroup); 5790 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, flatShading, blockGroup, true, 2 - interfaceBlockExpansionReducement); 5791 } 5792 { 5793 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(flatShading)); 5794 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "array", "Array types"); 5795 5796 targetGroup->addChild(blockGroup); 5797 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, arrayElement, blockGroup, true, 2 - interfaceBlockExpansionReducement); 5798 } 5799 { 5800 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(flatShading)); 5801 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "struct", "Struct types"); 5802 5803 targetGroup->addChild(blockGroup); 5804 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, structMember, blockGroup, true, 2 - interfaceBlockExpansionReducement); 5805 } 5806 } 5807 else if (firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL || 5808 firstStage == glu::SHADERTYPE_GEOMETRY) 5809 { 5810 // arrayed interface 5811 5812 // Only basic types (and no booleans) 5813 const ResourceDefinition::Node::SharedPtr arrayElement(new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5814 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, arrayElement, targetGroup, true, 2); 5815 } 5816 else if (firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION) 5817 { 5818 // arrayed interface 5819 const ResourceDefinition::Node::SharedPtr patchInput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_IN)); 5820 5821 // .var 5822 { 5823 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5824 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types"); 5825 5826 targetGroup->addChild(blockGroup); 5827 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, arrayElem, blockGroup, true, 2); 5828 } 5829 // extension forbids use arrays of structs 5830 // extension forbids use arrays of arrays 5831 5832 // .patch_var 5833 { 5834 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var", "Basic types, per-patch"); 5835 5836 targetGroup->addChild(blockGroup); 5837 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, patchInput, blockGroup, true, 1); 5838 } 5839 // .patch_var_struct 5840 { 5841 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchInput)); 5842 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var_struct", "Struct types, per-patch"); 5843 5844 targetGroup->addChild(blockGroup); 5845 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, structMbr, blockGroup, true, 1); 5846 } 5847 // .patch_var_array 5848 { 5849 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchInput)); 5850 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var_array", "Array types, per-patch"); 5851 5852 targetGroup->addChild(blockGroup); 5853 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, arrayElem, blockGroup, true, 1); 5854 } 5855 } 5856 else if (firstStage == glu::SHADERTYPE_COMPUTE) 5857 { 5858 // nada 5859 } 5860 else 5861 DE_ASSERT(false); 5862 } 5863 5864 static void generateProgramOutputTypeBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask) 5865 { 5866 const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK; 5867 const ResourceDefinition::Node::SharedPtr output = (inDefaultBlock) 5868 ? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_OUT))) 5869 : (parentStructure); 5870 const glu::ShaderType lastStage = getShaderMaskLastStage(presentShadersMask); 5871 const int interfaceBlockExpansionReducement = (!inDefaultBlock) ? (1) : (0); // lesser expansions on block members to keep test counts reasonable 5872 5873 if (lastStage == glu::SHADERTYPE_VERTEX || 5874 lastStage == glu::SHADERTYPE_GEOMETRY || 5875 lastStage == glu::SHADERTYPE_TESSELLATION_EVALUATION || 5876 !inDefaultBlock) 5877 { 5878 const ResourceDefinition::Node::SharedPtr flatShading(new ResourceDefinition::InterpolationQualifier(output, glu::INTERPOLATION_FLAT)); 5879 5880 // Only basic types, arrays of basic types, struct of basic types (and no booleans) 5881 { 5882 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types"); 5883 targetGroup->addChild(blockGroup); 5884 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, flatShading, blockGroup, true, 2 - interfaceBlockExpansionReducement); 5885 } 5886 { 5887 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(flatShading)); 5888 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "array", "Array types"); 5889 const int typeExpansionReducement = (lastStage != glu::SHADERTYPE_VERTEX) ? (1) : (0); // lesser expansions on other stages 5890 const int expansionLevel = 2 - interfaceBlockExpansionReducement - typeExpansionReducement; 5891 5892 targetGroup->addChild(blockGroup); 5893 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, arrayElement, blockGroup, true, expansionLevel); 5894 } 5895 { 5896 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(flatShading)); 5897 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "struct", "Struct types"); 5898 const int typeExpansionReducement = (lastStage != glu::SHADERTYPE_VERTEX) ? (1) : (0); // lesser expansions on other stages 5899 const int expansionLevel = 2 - interfaceBlockExpansionReducement - typeExpansionReducement; 5900 5901 targetGroup->addChild(blockGroup); 5902 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, structMember, blockGroup, true, expansionLevel); 5903 } 5904 } 5905 else if (lastStage == glu::SHADERTYPE_FRAGMENT) 5906 { 5907 // only basic type and basic type array (and no booleans or matrices) 5908 { 5909 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types"); 5910 targetGroup->addChild(blockGroup); 5911 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, output, blockGroup, false, 2); 5912 } 5913 { 5914 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(output)); 5915 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "array", "Array types"); 5916 5917 targetGroup->addChild(blockGroup); 5918 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, arrayElement, blockGroup, false, 2); 5919 } 5920 } 5921 else if (lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL) 5922 { 5923 // arrayed interface 5924 const ResourceDefinition::Node::SharedPtr patchOutput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_OUT)); 5925 5926 // .var 5927 { 5928 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 5929 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types"); 5930 5931 targetGroup->addChild(blockGroup); 5932 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, arrayElem, blockGroup, true, 2); 5933 } 5934 // extension forbids use arrays of structs 5935 // extension forbids use arrays of arrays 5936 5937 // .patch_var 5938 { 5939 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var", "Basic types, per-patch"); 5940 5941 targetGroup->addChild(blockGroup); 5942 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, patchOutput, blockGroup, true, 1); 5943 } 5944 // .patch_var_struct 5945 { 5946 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchOutput)); 5947 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var_struct", "Struct types, per-patch"); 5948 5949 targetGroup->addChild(blockGroup); 5950 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, structMbr, blockGroup, true, 1); 5951 } 5952 // .patch_var_array 5953 { 5954 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchOutput)); 5955 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var_array", "Array types, per-patch"); 5956 5957 targetGroup->addChild(blockGroup); 5958 generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, arrayElem, blockGroup, true, 1); 5959 } 5960 } 5961 else if (lastStage == glu::SHADERTYPE_COMPUTE) 5962 { 5963 // nada 5964 } 5965 else 5966 DE_ASSERT(false); 5967 } 5968 5969 class ProgramInputTestGroup : public TestCaseGroup 5970 { 5971 public: 5972 ProgramInputTestGroup (Context& context); 5973 void init (void); 5974 }; 5975 5976 ProgramInputTestGroup::ProgramInputTestGroup (Context& context) 5977 : TestCaseGroup(context, "program_input", "Program input") 5978 { 5979 } 5980 5981 void ProgramInputTestGroup::init (void) 5982 { 5983 // .resource_list 5984 { 5985 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "resource_list", "Resource list"); 5986 addChild(blockGroup); 5987 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, true, true, generateProgramInputResourceListBlockContents); 5988 } 5989 5990 // .array_size 5991 { 5992 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "array_size", "Array size"); 5993 addChild(blockGroup); 5994 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, true, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>); 5995 } 5996 5997 // .location 5998 { 5999 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "location", "Location"); 6000 addChild(blockGroup); 6001 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, true, generateProgramInputLocationBlockContents); 6002 } 6003 6004 // .name_length 6005 { 6006 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "name_length", "Name length"); 6007 addChild(blockGroup); 6008 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, true, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>); 6009 } 6010 6011 // .referenced_by 6012 { 6013 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "referenced_by", "Reference by shader"); 6014 addChild(blockGroup); 6015 generateProgramInputOutputReferencedByCases(m_context, blockGroup, glu::STORAGE_IN); 6016 } 6017 6018 // .type 6019 { 6020 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "type", "Type"); 6021 addChild(blockGroup); 6022 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, true, generateProgramInputTypeBlockContents); 6023 } 6024 6025 // .is_per_patch 6026 { 6027 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "is_per_patch", "Is per patch"); 6028 addChild(blockGroup); 6029 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, true, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_IS_PER_PATCH>); 6030 } 6031 } 6032 6033 class ProgramOutputTestGroup : public TestCaseGroup 6034 { 6035 public: 6036 ProgramOutputTestGroup (Context& context); 6037 void init (void); 6038 }; 6039 6040 ProgramOutputTestGroup::ProgramOutputTestGroup (Context& context) 6041 : TestCaseGroup(context, "program_output", "Program output") 6042 { 6043 } 6044 6045 void ProgramOutputTestGroup::init (void) 6046 { 6047 // .resource_list 6048 { 6049 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "resource_list", "Resource list"); 6050 addChild(blockGroup); 6051 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, true, false, generateProgramOutputResourceListBlockContents); 6052 } 6053 6054 // .array_size 6055 { 6056 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "array_size", "Array size"); 6057 addChild(blockGroup); 6058 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, false, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>); 6059 } 6060 6061 // .location 6062 { 6063 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "location", "Location"); 6064 addChild(blockGroup); 6065 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, false, generateProgramOutputLocationBlockContents); 6066 } 6067 6068 // .name_length 6069 { 6070 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "name_length", "Name length"); 6071 addChild(blockGroup); 6072 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, false, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>); 6073 } 6074 6075 // .referenced_by 6076 { 6077 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "referenced_by", "Reference by shader"); 6078 addChild(blockGroup); 6079 generateProgramInputOutputReferencedByCases(m_context, blockGroup, glu::STORAGE_OUT); 6080 } 6081 6082 // .type 6083 { 6084 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "type", "Type"); 6085 addChild(blockGroup); 6086 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, false, generateProgramOutputTypeBlockContents); 6087 } 6088 6089 // .is_per_patch 6090 { 6091 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "is_per_patch", "Is per patch"); 6092 addChild(blockGroup); 6093 generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, false, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_IS_PER_PATCH>); 6094 } 6095 } 6096 6097 static void generateTransformFeedbackShaderCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, bool)) 6098 { 6099 static const struct 6100 { 6101 const char* name; 6102 deUint32 stageBits; 6103 deUint32 lastStageBit; 6104 bool reducedSet; 6105 } pipelines[] = 6106 { 6107 { 6108 "vertex_fragment", 6109 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT), 6110 (1 << glu::SHADERTYPE_VERTEX), 6111 false 6112 }, 6113 { 6114 "vertex_tess_fragment", 6115 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION), 6116 (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION), 6117 true 6118 }, 6119 { 6120 "vertex_geo_fragment", 6121 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_GEOMETRY), 6122 (1 << glu::SHADERTYPE_GEOMETRY), 6123 true 6124 }, 6125 { 6126 "vertex_tess_geo_fragment", 6127 (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION) | (1 << glu::SHADERTYPE_GEOMETRY), 6128 (1 << glu::SHADERTYPE_GEOMETRY), 6129 true 6130 }, 6131 }; 6132 static const struct 6133 { 6134 const char* name; 6135 glu::ShaderType stage; 6136 bool reducedSet; 6137 } singleStageCases[] = 6138 { 6139 { "separable_vertex", glu::SHADERTYPE_VERTEX, false }, 6140 { "separable_tess_eval", glu::SHADERTYPE_TESSELLATION_EVALUATION, true }, 6141 { "separable_geometry", glu::SHADERTYPE_GEOMETRY, true }, 6142 }; 6143 6144 // monolithic pipeline 6145 for (int pipelineNdx = 0; pipelineNdx < DE_LENGTH_OF_ARRAY(pipelines); ++pipelineNdx) 6146 { 6147 TestCaseGroup* const blockGroup = new TestCaseGroup(context, pipelines[pipelineNdx].name, ""); 6148 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 6149 const ResourceDefinition::Node::SharedPtr shaderSet (new ResourceDefinition::ShaderSet(program, 6150 glu::GLSL_VERSION_310_ES, 6151 pipelines[pipelineNdx].stageBits, 6152 pipelines[pipelineNdx].lastStageBit)); 6153 6154 targetGroup->addChild(blockGroup); 6155 blockContentGenerator(context, shaderSet, blockGroup, pipelines[pipelineNdx].reducedSet); 6156 } 6157 6158 // separable pipeline 6159 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(singleStageCases); ++ndx) 6160 { 6161 TestCaseGroup* const blockGroup = new TestCaseGroup(context, singleStageCases[ndx].name, ""); 6162 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true)); 6163 const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glu::GLSL_VERSION_310_ES)); 6164 6165 targetGroup->addChild(blockGroup); 6166 blockContentGenerator(context, shader, blockGroup, singleStageCases[ndx].reducedSet); 6167 } 6168 } 6169 6170 static void generateTransformFeedbackResourceListBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool reducedSet) 6171 { 6172 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure)); 6173 const ResourceDefinition::Node::SharedPtr output (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_OUT)); 6174 6175 DE_UNREF(reducedSet); 6176 6177 // .builtin_gl_position 6178 { 6179 const ResourceDefinition::Node::SharedPtr xfbTarget(new ResourceDefinition::TransformFeedbackTarget(defaultBlock, "gl_Position")); 6180 targetGroup->addChild(new FeedbackResourceListTestCase(context, xfbTarget, "builtin_gl_position")); 6181 } 6182 // .default_block_basic_type 6183 { 6184 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(output)); 6185 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4)); 6186 targetGroup->addChild(new FeedbackResourceListTestCase(context, variable, "default_block_basic_type")); 6187 } 6188 // .default_block_struct_member 6189 { 6190 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(output)); 6191 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(structMbr)); 6192 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4)); 6193 targetGroup->addChild(new FeedbackResourceListTestCase(context, variable, "default_block_struct_member")); 6194 } 6195 // .default_block_array 6196 { 6197 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(output)); 6198 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(xfbTarget)); 6199 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 6200 targetGroup->addChild(new FeedbackResourceListTestCase(context, variable, "default_block_array")); 6201 } 6202 // .default_block_array_element 6203 { 6204 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output)); 6205 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(arrayElem)); 6206 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4)); 6207 targetGroup->addChild(new FeedbackResourceListTestCase(context, variable, "default_block_array_element")); 6208 } 6209 } 6210 6211 template <ProgramResourcePropFlags TargetProp> 6212 static void generateTransformFeedbackVariableBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool reducedSet) 6213 { 6214 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure)); 6215 const ResourceDefinition::Node::SharedPtr output (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_OUT)); 6216 6217 DE_UNREF(reducedSet); 6218 6219 // .builtin_gl_position 6220 { 6221 const ResourceDefinition::Node::SharedPtr xfbTarget(new ResourceDefinition::TransformFeedbackTarget(defaultBlock, "gl_Position")); 6222 targetGroup->addChild(new ResourceTestCase(context, xfbTarget, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, TargetProp), "builtin_gl_position")); 6223 } 6224 // .default_block_basic_type 6225 { 6226 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(output)); 6227 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4)); 6228 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, TargetProp), "default_block_basic_type")); 6229 } 6230 // .default_block_struct_member 6231 { 6232 const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(output)); 6233 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(structMbr)); 6234 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4)); 6235 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, TargetProp), "default_block_struct_member")); 6236 } 6237 // .default_block_array 6238 { 6239 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(output)); 6240 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(xfbTarget)); 6241 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4)); 6242 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, TargetProp), "default_block_array")); 6243 } 6244 // .default_block_array_element 6245 { 6246 const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output)); 6247 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(arrayElem)); 6248 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4)); 6249 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, TargetProp), "default_block_array_element")); 6250 } 6251 } 6252 6253 static void generateTransformFeedbackVariableBasicTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool reducedSet) 6254 { 6255 static const struct 6256 { 6257 glu::DataType type; 6258 bool important; 6259 } variableTypes[] = 6260 { 6261 { glu::TYPE_FLOAT, true }, 6262 { glu::TYPE_INT, true }, 6263 { glu::TYPE_UINT, true }, 6264 6265 { glu::TYPE_FLOAT_VEC2, false }, 6266 { glu::TYPE_FLOAT_VEC3, true }, 6267 { glu::TYPE_FLOAT_VEC4, false }, 6268 6269 { glu::TYPE_INT_VEC2, false }, 6270 { glu::TYPE_INT_VEC3, true }, 6271 { glu::TYPE_INT_VEC4, false }, 6272 6273 { glu::TYPE_UINT_VEC2, true }, 6274 { glu::TYPE_UINT_VEC3, false }, 6275 { glu::TYPE_UINT_VEC4, false }, 6276 6277 { glu::TYPE_FLOAT_MAT2, false }, 6278 { glu::TYPE_FLOAT_MAT2X3, false }, 6279 { glu::TYPE_FLOAT_MAT2X4, false }, 6280 { glu::TYPE_FLOAT_MAT3X2, false }, 6281 { glu::TYPE_FLOAT_MAT3, false }, 6282 { glu::TYPE_FLOAT_MAT3X4, true }, 6283 { glu::TYPE_FLOAT_MAT4X2, false }, 6284 { glu::TYPE_FLOAT_MAT4X3, false }, 6285 { glu::TYPE_FLOAT_MAT4, false }, 6286 }; 6287 6288 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx) 6289 { 6290 if (variableTypes[ndx].important || !reducedSet) 6291 { 6292 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].type)); 6293 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, PROGRAMRESOURCEPROP_TYPE))); 6294 } 6295 } 6296 } 6297 6298 static void generateTransformFeedbackVariableTypeBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool reducedSet) 6299 { 6300 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure)); 6301 const ResourceDefinition::Node::SharedPtr output (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_OUT)); 6302 const ResourceDefinition::Node::SharedPtr flatShading (new ResourceDefinition::InterpolationQualifier(output, glu::INTERPOLATION_FLAT)); 6303 6304 // Only builtins, basic types, arrays of basic types, struct of basic types (and no booleans) 6305 { 6306 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(defaultBlock, "gl_Position")); 6307 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "builtin", "Built-in outputs"); 6308 6309 targetGroup->addChild(blockGroup); 6310 blockGroup->addChild(new ResourceTestCase(context, xfbTarget, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, PROGRAMRESOURCEPROP_TYPE), "gl_position")); 6311 } 6312 { 6313 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(flatShading)); 6314 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types"); 6315 6316 targetGroup->addChild(blockGroup); 6317 generateTransformFeedbackVariableBasicTypeCases(context, xfbTarget, blockGroup, reducedSet); 6318 } 6319 { 6320 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(flatShading)); 6321 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(arrayElement)); 6322 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "array", "Array types"); 6323 6324 targetGroup->addChild(blockGroup); 6325 generateTransformFeedbackVariableBasicTypeCases(context, xfbTarget, blockGroup, reducedSet); 6326 } 6327 { 6328 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(flatShading)); 6329 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(xfbTarget)); 6330 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "whole_array", "Whole array"); 6331 6332 targetGroup->addChild(blockGroup); 6333 generateTransformFeedbackVariableBasicTypeCases(context, arrayElement, blockGroup, reducedSet); 6334 } 6335 { 6336 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(flatShading)); 6337 const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(structMember)); 6338 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "struct", "Struct types"); 6339 6340 targetGroup->addChild(blockGroup); 6341 generateTransformFeedbackVariableBasicTypeCases(context, xfbTarget, blockGroup, reducedSet); 6342 } 6343 } 6344 6345 class TransformFeedbackVaryingTestGroup : public TestCaseGroup 6346 { 6347 public: 6348 TransformFeedbackVaryingTestGroup (Context& context); 6349 void init (void); 6350 }; 6351 6352 TransformFeedbackVaryingTestGroup::TransformFeedbackVaryingTestGroup (Context& context) 6353 : TestCaseGroup(context, "transform_feedback_varying", "Transform feedback varyings") 6354 { 6355 } 6356 6357 void TransformFeedbackVaryingTestGroup::init (void) 6358 { 6359 // .resource_list 6360 { 6361 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "resource_list", "Resource list"); 6362 addChild(blockGroup); 6363 generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, generateTransformFeedbackResourceListBlockContents); 6364 } 6365 6366 // .array_size 6367 { 6368 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "array_size", "Array size"); 6369 addChild(blockGroup); 6370 generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, generateTransformFeedbackVariableBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>); 6371 } 6372 6373 // .name_length 6374 { 6375 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "name_length", "Name length"); 6376 addChild(blockGroup); 6377 generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, generateTransformFeedbackVariableBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>); 6378 } 6379 6380 // .type 6381 { 6382 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "type", "Type"); 6383 addChild(blockGroup); 6384 generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, generateTransformFeedbackVariableTypeBlockContents); 6385 } 6386 } 6387 6388 static void generateBufferVariableBufferCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*)) 6389 { 6390 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 6391 const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES)); 6392 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 6393 const ResourceDefinition::Node::SharedPtr bufferStorage (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER)); 6394 const ResourceDefinition::Node::SharedPtr binding (new ResourceDefinition::LayoutQualifier(bufferStorage, glu::Layout(-1, 0))); 6395 6396 // .named_block 6397 { 6398 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, true)); 6399 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "named_block", "Named block"); 6400 6401 targetGroup->addChild(blockGroup); 6402 6403 blockContentGenerator(context, buffer, blockGroup); 6404 } 6405 6406 // .unnamed_block 6407 { 6408 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, false)); 6409 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unnamed_block", "Unnamed block"); 6410 6411 targetGroup->addChild(blockGroup); 6412 6413 blockContentGenerator(context, buffer, blockGroup); 6414 } 6415 6416 // .block_array 6417 { 6418 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding)); 6419 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(arrayElement, true)); 6420 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "block_array", "Block array"); 6421 6422 targetGroup->addChild(blockGroup); 6423 6424 blockContentGenerator(context, buffer, blockGroup); 6425 } 6426 } 6427 6428 static void generateBufferVariableResourceListBlockContentsProxy (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup) 6429 { 6430 generateBufferBackedResourceListBlockContentCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, 4); 6431 } 6432 6433 static void generateBufferVariableArraySizeSubCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, ProgramResourcePropFlags targetProp, bool sizedArray, bool extendedCases) 6434 { 6435 const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_BUFFER_VARIABLE, targetProp); 6436 tcu::TestCaseGroup* aggregateGroup; 6437 6438 // .types 6439 if (extendedCases) 6440 { 6441 tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types"); 6442 targetGroup->addChild(blockGroup); 6443 6444 generateVariableCases(context, parentStructure, blockGroup, queryTarget, (sizedArray) ? (2) : (1), false); 6445 } 6446 6447 // .aggregates 6448 if (extendedCases) 6449 { 6450 aggregateGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "Aggregate types"); 6451 targetGroup->addChild(aggregateGroup); 6452 } 6453 else 6454 aggregateGroup = targetGroup; 6455 6456 // .float_* 6457 generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_FLOAT, (extendedCases && sizedArray) ? (2) : (1), !extendedCases); 6458 6459 // .bool_* 6460 generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_BOOL, (extendedCases && sizedArray) ? (1) : (0), !extendedCases); 6461 6462 // .bvec3_* 6463 generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_BOOL_VEC3, (extendedCases && sizedArray) ? (2) : (1), !extendedCases); 6464 6465 // .vec4_* 6466 generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_FLOAT_VEC4, (extendedCases && sizedArray) ? (2) : (1), !extendedCases); 6467 6468 // .ivec2_* 6469 generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_INT_VEC2, (extendedCases && sizedArray) ? (2) : (1), !extendedCases); 6470 } 6471 6472 template <ProgramResourcePropFlags TargetProp> 6473 static void generateBufferVariableArrayCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup) 6474 { 6475 const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_BUFFER_VARIABLE, TargetProp); 6476 const bool namedNonArrayBlock = static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named && parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT; 6477 6478 // .non_array 6479 if (namedNonArrayBlock) 6480 { 6481 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "non_array", "Non-array target"); 6482 targetGroup->addChild(blockGroup); 6483 6484 generateVariableCases(context, parentStructure, blockGroup, queryTarget, 1, false); 6485 } 6486 6487 // .sized 6488 { 6489 const ResourceDefinition::Node::SharedPtr sized (new ResourceDefinition::ArrayElement(parentStructure)); 6490 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "sized", "Sized target"); 6491 targetGroup->addChild(blockGroup); 6492 6493 generateBufferVariableArraySizeSubCases(context, sized, blockGroup, TargetProp, true, namedNonArrayBlock); 6494 } 6495 6496 // .unsized 6497 { 6498 const ResourceDefinition::Node::SharedPtr unsized (new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 6499 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unsized", "Unsized target"); 6500 targetGroup->addChild(blockGroup); 6501 6502 generateBufferVariableArraySizeSubCases(context, unsized, blockGroup, TargetProp, false, namedNonArrayBlock); 6503 } 6504 } 6505 6506 static void generateBufferVariableBlockIndexCases (Context& context, tcu::TestCaseGroup* const targetGroup) 6507 { 6508 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 6509 const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES)); 6510 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 6511 const ResourceDefinition::Node::SharedPtr bufferStorage (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER)); 6512 const ResourceDefinition::Node::SharedPtr binding (new ResourceDefinition::LayoutQualifier(bufferStorage, glu::Layout(-1, 0))); 6513 6514 // .named_block 6515 { 6516 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, true)); 6517 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4)); 6518 6519 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_BLOCK_INDEX), "named_block")); 6520 } 6521 6522 // .unnamed_block 6523 { 6524 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, false)); 6525 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4)); 6526 6527 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_BLOCK_INDEX), "unnamed_block")); 6528 } 6529 6530 // .block_array 6531 { 6532 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding)); 6533 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(arrayElement, true)); 6534 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4)); 6535 6536 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_BLOCK_INDEX), "block_array")); 6537 } 6538 } 6539 6540 static void generateBufferVariableMatrixCaseBlocks (Context& context, tcu::TestCaseGroup* const targetGroup, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, bool)) 6541 { 6542 static const struct 6543 { 6544 const char* name; 6545 const char* description; 6546 bool namedBlock; 6547 bool extendedBasicTypeCases; 6548 glu::MatrixOrder order; 6549 } children[] = 6550 { 6551 { "named_block", "Named uniform block", true, true, glu::MATRIXORDER_LAST }, 6552 { "named_block_row_major", "Named uniform block", true, false, glu::MATRIXORDER_ROW_MAJOR }, 6553 { "named_block_col_major", "Named uniform block", true, false, glu::MATRIXORDER_COLUMN_MAJOR }, 6554 { "unnamed_block", "Unnamed uniform block", false, false, glu::MATRIXORDER_LAST }, 6555 { "unnamed_block_row_major", "Unnamed uniform block", false, false, glu::MATRIXORDER_ROW_MAJOR }, 6556 { "unnamed_block_col_major", "Unnamed uniform block", false, false, glu::MATRIXORDER_COLUMN_MAJOR }, 6557 }; 6558 6559 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 6560 const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES)); 6561 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 6562 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER)); 6563 6564 for (int childNdx = 0; childNdx < (int)DE_LENGTH_OF_ARRAY(children); ++childNdx) 6565 { 6566 ResourceDefinition::Node::SharedPtr parentStructure = buffer; 6567 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, children[childNdx].name, children[childNdx].description); 6568 6569 targetGroup->addChild(blockGroup); 6570 6571 if (children[childNdx].order != glu::MATRIXORDER_LAST) 6572 { 6573 glu::Layout layout; 6574 layout.matrixOrder = children[childNdx].order; 6575 parentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(parentStructure, layout)); 6576 } 6577 6578 parentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::InterfaceBlock(parentStructure, children[childNdx].namedBlock)); 6579 6580 blockContentGenerator(context, parentStructure, blockGroup, children[childNdx].extendedBasicTypeCases); 6581 } 6582 } 6583 6584 static void generateBufferVariableMatrixVariableBasicTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, ProgramResourcePropFlags targetProp) 6585 { 6586 // all matrix types and some non-matrix 6587 6588 static const glu::DataType variableTypes[] = 6589 { 6590 glu::TYPE_FLOAT, 6591 glu::TYPE_INT_VEC3, 6592 glu::TYPE_FLOAT_MAT2, 6593 glu::TYPE_FLOAT_MAT2X3, 6594 glu::TYPE_FLOAT_MAT2X4, 6595 glu::TYPE_FLOAT_MAT3X2, 6596 glu::TYPE_FLOAT_MAT3, 6597 glu::TYPE_FLOAT_MAT3X4, 6598 glu::TYPE_FLOAT_MAT4X2, 6599 glu::TYPE_FLOAT_MAT4X3, 6600 glu::TYPE_FLOAT_MAT4, 6601 }; 6602 6603 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx) 6604 { 6605 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx])); 6606 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, targetProp))); 6607 } 6608 } 6609 6610 static void generateBufferVariableMatrixVariableCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, ProgramResourcePropFlags targetProp) 6611 { 6612 // Basic aggregates 6613 generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, targetProp, glu::TYPE_FLOAT_MAT3X2, "", 2); 6614 6615 // Unsized array 6616 { 6617 const ResourceDefinition::Node::SharedPtr unsized (new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 6618 const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(unsized, glu::TYPE_FLOAT_MAT3X2)); 6619 6620 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, targetProp), "var_unsized_array")); 6621 } 6622 } 6623 6624 template <ProgramResourcePropFlags TargetProp> 6625 static void generateBufferVariableMatrixCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool extendedTypeCases) 6626 { 6627 // .types 6628 if (extendedTypeCases) 6629 { 6630 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "types", "Types"); 6631 targetGroup->addChild(blockGroup); 6632 generateBufferVariableMatrixVariableBasicTypeCases(context, parentStructure, blockGroup, TargetProp); 6633 } 6634 6635 // .no_qualifier 6636 { 6637 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "no_qualifier", "No qualifier"); 6638 targetGroup->addChild(blockGroup); 6639 generateBufferVariableMatrixVariableCases(context, parentStructure, blockGroup, TargetProp); 6640 } 6641 6642 // .column_major 6643 { 6644 const ResourceDefinition::Node::SharedPtr matrixOrder(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, -1, -1, glu::FORMATLAYOUT_LAST, glu::MATRIXORDER_COLUMN_MAJOR))); 6645 6646 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "column_major", "Column major qualifier"); 6647 targetGroup->addChild(blockGroup); 6648 generateBufferVariableMatrixVariableCases(context, matrixOrder, blockGroup, TargetProp); 6649 } 6650 6651 // .row_major 6652 { 6653 const ResourceDefinition::Node::SharedPtr matrixOrder(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, -1, -1, glu::FORMATLAYOUT_LAST, glu::MATRIXORDER_ROW_MAJOR))); 6654 6655 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "row_major", "Row major qualifier"); 6656 targetGroup->addChild(blockGroup); 6657 generateBufferVariableMatrixVariableCases(context, matrixOrder, blockGroup, TargetProp); 6658 } 6659 } 6660 6661 static void generateBufferVariableNameLengthCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup) 6662 { 6663 // .sized 6664 { 6665 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "sized", "Sized target"); 6666 targetGroup->addChild(blockGroup); 6667 6668 generateBufferBackedVariableAggregateTypeCases(context, parentStructure, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 3); 6669 } 6670 6671 // .unsized 6672 { 6673 const ResourceDefinition::Node::SharedPtr unsized (new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 6674 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unsized", "Unsized target"); 6675 targetGroup->addChild(blockGroup); 6676 6677 generateBufferBackedVariableAggregateTypeCases(context, unsized, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 2); 6678 } 6679 } 6680 6681 static void generateBufferVariableOffsetCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup) 6682 { 6683 // .sized 6684 { 6685 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "sized", "Sized target"); 6686 targetGroup->addChild(blockGroup); 6687 6688 generateBufferBackedVariableAggregateTypeCases(context, parentStructure, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_OFFSET, glu::TYPE_FLOAT, "", 3); 6689 } 6690 6691 // .unsized 6692 { 6693 const ResourceDefinition::Node::SharedPtr unsized (new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 6694 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unsized", "Unsized target"); 6695 targetGroup->addChild(blockGroup); 6696 6697 generateBufferBackedVariableAggregateTypeCases(context, unsized, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_OFFSET, glu::TYPE_FLOAT, "", 2); 6698 } 6699 } 6700 6701 static void generateBufferVariableReferencedByBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, int expandLevel) 6702 { 6703 DE_UNREF(expandLevel); 6704 6705 const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_REFERENCED_BY_SHADER); 6706 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure)); 6707 const ResourceDefinition::Node::SharedPtr storage (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER)); 6708 const bool singleShaderCase = parentStructure->getType() == ResourceDefinition::Node::TYPE_SHADER; 6709 6710 // .named_block 6711 { 6712 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(storage, true)); 6713 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "named_block", "Named block"); 6714 6715 targetGroup->addChild(blockGroup); 6716 6717 generateBufferReferencedByShaderInterfaceBlockCases(context, buffer, blockGroup, queryTarget, singleShaderCase); 6718 } 6719 6720 // .unnamed_block 6721 { 6722 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(storage, false)); 6723 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unnamed_block", "Unnamed block"); 6724 6725 targetGroup->addChild(blockGroup); 6726 6727 generateBufferReferencedByShaderInterfaceBlockCases(context, buffer, blockGroup, queryTarget, false); 6728 } 6729 6730 // .block_array 6731 { 6732 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(storage)); 6733 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(arrayElement, true)); 6734 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "block_array", "Block array"); 6735 6736 targetGroup->addChild(blockGroup); 6737 6738 generateBufferReferencedByShaderInterfaceBlockCases(context, buffer, blockGroup, queryTarget, false); 6739 } 6740 } 6741 6742 template <ProgramResourcePropFlags TargetProp> 6743 static void generateBufferVariableTopLevelCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup) 6744 { 6745 // basic and aggregate types 6746 generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, TargetProp, glu::TYPE_FLOAT_VEC4, "", 3); 6747 6748 // basic and aggregate types in an unsized array 6749 { 6750 const ResourceDefinition::Node::SharedPtr unsized(new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY)); 6751 6752 generateBufferBackedVariableAggregateTypeCases(context, unsized, targetGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, TargetProp, glu::TYPE_FLOAT_VEC4, "_unsized_array", 2); 6753 } 6754 } 6755 6756 static void generateBufferVariableTypeBasicTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, int expandLevel) 6757 { 6758 static const struct 6759 { 6760 int level; 6761 glu::DataType dataType; 6762 } variableTypes[] = 6763 { 6764 { 0, glu::TYPE_FLOAT }, 6765 { 1, glu::TYPE_INT }, 6766 { 1, glu::TYPE_UINT }, 6767 { 1, glu::TYPE_BOOL }, 6768 6769 { 3, glu::TYPE_FLOAT_VEC2 }, 6770 { 1, glu::TYPE_FLOAT_VEC3 }, 6771 { 1, glu::TYPE_FLOAT_VEC4 }, 6772 6773 { 3, glu::TYPE_INT_VEC2 }, 6774 { 2, glu::TYPE_INT_VEC3 }, 6775 { 3, glu::TYPE_INT_VEC4 }, 6776 6777 { 3, glu::TYPE_UINT_VEC2 }, 6778 { 2, glu::TYPE_UINT_VEC3 }, 6779 { 3, glu::TYPE_UINT_VEC4 }, 6780 6781 { 3, glu::TYPE_BOOL_VEC2 }, 6782 { 2, glu::TYPE_BOOL_VEC3 }, 6783 { 3, glu::TYPE_BOOL_VEC4 }, 6784 6785 { 2, glu::TYPE_FLOAT_MAT2 }, 6786 { 3, glu::TYPE_FLOAT_MAT2X3 }, 6787 { 3, glu::TYPE_FLOAT_MAT2X4 }, 6788 { 2, glu::TYPE_FLOAT_MAT3X2 }, 6789 { 2, glu::TYPE_FLOAT_MAT3 }, 6790 { 3, glu::TYPE_FLOAT_MAT3X4 }, 6791 { 2, glu::TYPE_FLOAT_MAT4X2 }, 6792 { 3, glu::TYPE_FLOAT_MAT4X3 }, 6793 { 2, glu::TYPE_FLOAT_MAT4 }, 6794 }; 6795 6796 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx) 6797 { 6798 if (variableTypes[ndx].level <= expandLevel) 6799 { 6800 const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].dataType)); 6801 targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_TYPE))); 6802 } 6803 } 6804 } 6805 6806 static void generateBufferVariableTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, int depth = 3) 6807 { 6808 // .basic_type 6809 if (depth > 0) 6810 { 6811 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic type"); 6812 targetGroup->addChild(blockGroup); 6813 generateBufferVariableTypeBasicTypeCases(context, parentStructure, blockGroup, depth); 6814 } 6815 else 6816 { 6817 // flatten bottom-level 6818 generateBufferVariableTypeBasicTypeCases(context, parentStructure, targetGroup, depth); 6819 } 6820 6821 // .array 6822 if (depth > 0) 6823 { 6824 const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure)); 6825 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "array", "Arrays"); 6826 6827 targetGroup->addChild(blockGroup); 6828 generateBufferVariableTypeCases(context, arrayElement, blockGroup, depth-1); 6829 } 6830 6831 // .struct 6832 if (depth > 0) 6833 { 6834 const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure)); 6835 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "struct", "Structs"); 6836 6837 targetGroup->addChild(blockGroup); 6838 generateBufferVariableTypeCases(context, structMember, blockGroup, depth-1); 6839 } 6840 } 6841 6842 static void generateBufferVariableTypeBlock (Context& context, tcu::TestCaseGroup* targetGroup) 6843 { 6844 const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program()); 6845 const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES)); 6846 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 6847 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER)); 6848 const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(buffer, true)); 6849 6850 generateBufferVariableTypeCases(context, block, targetGroup); 6851 } 6852 6853 static void generateBufferVariableRandomCase (Context& context, tcu::TestCaseGroup* const targetGroup, int index, bool onlyExtensionStages) 6854 { 6855 de::Random rnd (index * 0x12345); 6856 const ResourceDefinition::Node::SharedPtr shader = generateRandomShaderSet(rnd, onlyExtensionStages); 6857 const glu::DataType type = generateRandomDataType(rnd, true); 6858 const glu::Layout layout = generateRandomVariableLayout(rnd, type, true); 6859 const bool namedBlock = rnd.getBool(); 6860 const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader)); 6861 const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER)); 6862 ResourceDefinition::Node::SharedPtr currentStructure (new ResourceDefinition::LayoutQualifier(buffer, generateRandomBufferBlockLayout(rnd))); 6863 6864 if (namedBlock && rnd.getBool()) 6865 currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::ArrayElement(currentStructure)); 6866 currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::InterfaceBlock(currentStructure, namedBlock)); 6867 6868 currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(currentStructure, layout)); 6869 currentStructure = generateRandomVariableDefinition(rnd, currentStructure, type, layout, true); 6870 6871 targetGroup->addChild(new ResourceTestCase(context, currentStructure, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_BUFFER_VARIABLE_MASK), de::toString(index).c_str())); 6872 } 6873 6874 static void generateBufferVariableRandomCases (Context& context, tcu::TestCaseGroup* const targetGroup) 6875 { 6876 const int numBasicCases = 40; 6877 const int numTessGeoCases = 40; 6878 6879 for (int ndx = 0; ndx < numBasicCases; ++ndx) 6880 generateBufferVariableRandomCase(context, targetGroup, ndx, false); 6881 for (int ndx = 0; ndx < numTessGeoCases; ++ndx) 6882 generateBufferVariableRandomCase(context, targetGroup, numBasicCases + ndx, true); 6883 } 6884 6885 class BufferVariableTestGroup : public TestCaseGroup 6886 { 6887 public: 6888 BufferVariableTestGroup (Context& context); 6889 void init (void); 6890 }; 6891 6892 BufferVariableTestGroup::BufferVariableTestGroup (Context& context) 6893 : TestCaseGroup(context, "buffer_variable", "Buffer variable") 6894 { 6895 } 6896 6897 void BufferVariableTestGroup::init (void) 6898 { 6899 // .resource_list 6900 { 6901 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "resource_list", "Resource list"); 6902 addChild(blockGroup); 6903 generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableResourceListBlockContentsProxy); 6904 } 6905 6906 // .array_size 6907 { 6908 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "array_size", "Array size"); 6909 addChild(blockGroup); 6910 generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableArrayCases<PROGRAMRESOURCEPROP_ARRAY_SIZE>); 6911 } 6912 6913 // .array_stride 6914 { 6915 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "array_stride", "Array stride"); 6916 addChild(blockGroup); 6917 generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableArrayCases<PROGRAMRESOURCEPROP_ARRAY_STRIDE>); 6918 } 6919 6920 // .block_index 6921 { 6922 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "block_index", "Block index"); 6923 addChild(blockGroup); 6924 generateBufferVariableBlockIndexCases(m_context, blockGroup); 6925 } 6926 6927 // .is_row_major 6928 { 6929 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "is_row_major", "Is row major"); 6930 addChild(blockGroup); 6931 generateBufferVariableMatrixCaseBlocks(m_context, blockGroup, generateBufferVariableMatrixCases<PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR>); 6932 } 6933 6934 // .matrix_stride 6935 { 6936 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "matrix_stride", "Matrix stride"); 6937 addChild(blockGroup); 6938 generateBufferVariableMatrixCaseBlocks(m_context, blockGroup, generateBufferVariableMatrixCases<PROGRAMRESOURCEPROP_MATRIX_STRIDE>); 6939 } 6940 6941 // .name_length 6942 { 6943 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "name_length", "Name length"); 6944 addChild(blockGroup); 6945 generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableNameLengthCases); 6946 } 6947 6948 // .offset 6949 { 6950 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "offset", "Offset"); 6951 addChild(blockGroup); 6952 generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableOffsetCases); 6953 } 6954 6955 // .referenced_by 6956 { 6957 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "referenced_by", "Referenced by"); 6958 addChild(blockGroup); 6959 generateReferencedByShaderCaseBlocks(m_context, blockGroup, generateBufferVariableReferencedByBlockContents); 6960 } 6961 6962 // .top_level_array_size 6963 { 6964 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "top_level_array_size", "Top-level array size"); 6965 addChild(blockGroup); 6966 generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableTopLevelCases<PROGRAMRESOURCEPROP_TOP_LEVEL_ARRAY_SIZE>); 6967 } 6968 6969 // .top_level_array_stride 6970 { 6971 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "top_level_array_stride", "Top-level array stride"); 6972 addChild(blockGroup); 6973 generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableTopLevelCases<PROGRAMRESOURCEPROP_TOP_LEVEL_ARRAY_STRIDE>); 6974 } 6975 6976 // .type 6977 { 6978 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "type", "Type"); 6979 addChild(blockGroup); 6980 generateBufferVariableTypeBlock(m_context, blockGroup); 6981 } 6982 6983 // .random 6984 { 6985 tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "random", "Random"); 6986 addChild(blockGroup); 6987 generateBufferVariableRandomCases(m_context, blockGroup); 6988 } 6989 } 6990 6991 } // anonymous 6992 6993 ProgramInterfaceQueryTests::ProgramInterfaceQueryTests (Context& context) 6994 : TestCaseGroup(context, "program_interface_query", "Program interface query tests") 6995 { 6996 } 6997 6998 ProgramInterfaceQueryTests::~ProgramInterfaceQueryTests (void) 6999 { 7000 } 7001 7002 void ProgramInterfaceQueryTests::init (void) 7003 { 7004 // Misc queries 7005 7006 // .buffer_limited_query 7007 { 7008 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "buffer_limited_query", "Queries limited by the buffer size"); 7009 7010 addChild(group); 7011 7012 group->addChild(new ResourceNameBufferLimitCase(m_context, "resource_name_query", "Test GetProgramResourceName with too small a buffer")); 7013 group->addChild(new ResourceQueryBufferLimitCase(m_context, "resource_query", "Test GetProgramResourceiv with too small a buffer")); 7014 } 7015 7016 // Interfaces 7017 7018 // .uniform 7019 addChild(new UniformInterfaceTestGroup(m_context)); 7020 7021 // .uniform_block 7022 addChild(new BufferBackedBlockInterfaceTestGroup(m_context, glu::STORAGE_UNIFORM)); 7023 7024 // .atomic_counter_buffer 7025 addChild(new AtomicCounterTestGroup(m_context)); 7026 7027 // .program_input 7028 addChild(new ProgramInputTestGroup(m_context)); 7029 7030 // .program_output 7031 addChild(new ProgramOutputTestGroup(m_context)); 7032 7033 // .transform_feedback_varying 7034 addChild(new TransformFeedbackVaryingTestGroup(m_context)); 7035 7036 // .buffer_variable 7037 addChild(new BufferVariableTestGroup(m_context)); 7038 7039 // .shader_storage_block 7040 addChild(new BufferBackedBlockInterfaceTestGroup(m_context, glu::STORAGE_BUFFER)); 7041 } 7042 7043 } // Functional 7044 } // gles31 7045 } // deqp 7046
