1 /*------------------------------------------------------------------------ 2 * Vulkan Conformance Tests 3 * ------------------------ 4 * 5 * Copyright (c) 2014 The Android Open Source Project 6 * Copyright (c) 2016 The Khronos Group Inc. 7 * 8 * Licensed under the Apache License, Version 2.0 (the "License"); 9 * you may not use this file except in compliance with the License. 10 * You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, software 15 * distributed under the License is distributed on an "AS IS" BASIS, 16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 * See the License for the specific language governing permissions and 18 * limitations under the License. 19 * 20 *//*! 21 * \file 22 * \brief Tessellation User Defined IO Tests 23 *//*--------------------------------------------------------------------*/ 24 25 #include "vktTessellationUserDefinedIO.hpp" 26 #include "vktTestCaseUtil.hpp" 27 #include "vktTessellationUtil.hpp" 28 29 #include "tcuTestLog.hpp" 30 #include "tcuImageCompare.hpp" 31 #include "tcuImageIO.hpp" 32 33 #include "gluVarType.hpp" 34 #include "gluVarTypeUtil.hpp" 35 36 #include "vkDefs.hpp" 37 #include "vkQueryUtil.hpp" 38 #include "vkImageUtil.hpp" 39 #include "vkBuilderUtil.hpp" 40 #include "vkTypeUtil.hpp" 41 42 #include "deUniquePtr.hpp" 43 #include "deSharedPtr.hpp" 44 45 namespace vkt 46 { 47 namespace tessellation 48 { 49 50 using namespace vk; 51 52 namespace 53 { 54 55 enum Constants 56 { 57 NUM_PER_PATCH_BLOCKS = 2, 58 NUM_PER_PATCH_ARRAY_ELEMS = 3, 59 NUM_OUTPUT_VERTICES = 5, 60 NUM_TESS_LEVELS = 6, 61 MAX_TESSELLATION_PATCH_SIZE = 32, 62 RENDER_SIZE = 256, 63 }; 64 65 enum IOType 66 { 67 IO_TYPE_PER_PATCH = 0, 68 IO_TYPE_PER_PATCH_ARRAY, 69 IO_TYPE_PER_PATCH_BLOCK, 70 IO_TYPE_PER_PATCH_BLOCK_ARRAY, 71 IO_TYPE_PER_VERTEX, 72 IO_TYPE_PER_VERTEX_BLOCK, 73 74 IO_TYPE_LAST 75 }; 76 77 enum VertexIOArraySize 78 { 79 VERTEX_IO_ARRAY_SIZE_IMPLICIT = 0, 80 VERTEX_IO_ARRAY_SIZE_EXPLICIT_SHADER_BUILTIN, //!< Use gl_MaxPatchVertices as size for per-vertex input array. 81 VERTEX_IO_ARRAY_SIZE_EXPLICIT_SPEC_MIN, //!< Minimum maxTessellationPatchSize required by the spec. 82 83 VERTEX_IO_ARRAY_SIZE_LAST 84 }; 85 86 struct CaseDefinition 87 { 88 TessPrimitiveType primitiveType; 89 IOType ioType; 90 VertexIOArraySize vertexIOArraySize; 91 std::string referenceImagePath; 92 }; 93 94 typedef std::string (*BasicTypeVisitFunc)(const std::string& name, glu::DataType type, int indentationDepth); //!< See glslTraverseBasicTypes below. 95 96 class TopLevelObject 97 { 98 public: 99 virtual ~TopLevelObject (void) {} 100 101 virtual std::string name (void) const = 0; 102 virtual std::string declare (void) const = 0; 103 virtual std::string declareArray (const std::string& arraySizeExpr) const = 0; 104 virtual std::string glslTraverseBasicTypeArray (const int numArrayElements, //!< If negative, traverse just array[gl_InvocationID], not all indices. 105 const int indentationDepth, 106 BasicTypeVisitFunc) const = 0; 107 virtual std::string glslTraverseBasicType (const int indentationDepth, 108 BasicTypeVisitFunc) const = 0; 109 virtual int numBasicSubobjectsInElementType (void) const = 0; 110 virtual std::string basicSubobjectAtIndex (const int index, const int arraySize) const = 0; 111 }; 112 113 std::string glslTraverseBasicTypes (const std::string& rootName, 114 const glu::VarType& rootType, 115 const int arrayNestingDepth, 116 const int indentationDepth, 117 const BasicTypeVisitFunc visit) 118 { 119 if (rootType.isBasicType()) 120 return visit(rootName, rootType.getBasicType(), indentationDepth); 121 else if (rootType.isArrayType()) 122 { 123 const std::string indentation = std::string(indentationDepth, '\t'); 124 const std::string loopIndexName = "i" + de::toString(arrayNestingDepth); 125 const std::string arrayLength = de::toString(rootType.getArraySize()); 126 return indentation + "for (int " + loopIndexName + " = 0; " + loopIndexName + " < " + de::toString(rootType.getArraySize()) + "; ++" + loopIndexName + ")\n" + 127 indentation + "{\n" + 128 glslTraverseBasicTypes(rootName + "[" + loopIndexName + "]", rootType.getElementType(), arrayNestingDepth+1, indentationDepth+1, visit) + 129 indentation + "}\n"; 130 } 131 else if (rootType.isStructType()) 132 { 133 const glu::StructType& structType = *rootType.getStructPtr(); 134 const int numMembers = structType.getNumMembers(); 135 std::string result; 136 137 for (int membNdx = 0; membNdx < numMembers; ++membNdx) 138 { 139 const glu::StructMember& member = structType.getMember(membNdx); 140 result += glslTraverseBasicTypes(rootName + "." + member.getName(), member.getType(), arrayNestingDepth, indentationDepth, visit); 141 } 142 143 return result; 144 } 145 else 146 { 147 DE_ASSERT(false); 148 return DE_NULL; 149 } 150 } 151 152 //! Used as the 'visit' argument for glslTraverseBasicTypes. 153 std::string glslAssignBasicTypeObject (const std::string& name, const glu::DataType type, const int indentationDepth) 154 { 155 const int scalarSize = glu::getDataTypeScalarSize(type); 156 const std::string indentation = std::string(indentationDepth, '\t'); 157 std::ostringstream result; 158 159 result << indentation << name << " = "; 160 161 if (type != glu::TYPE_FLOAT) 162 result << std::string() << glu::getDataTypeName(type) << "("; 163 for (int i = 0; i < scalarSize; ++i) 164 result << (i > 0 ? ", v+" + de::floatToString(0.8f*(float)i, 1) : "v"); 165 if (type != glu::TYPE_FLOAT) 166 result << ")"; 167 result << ";\n" 168 << indentation << "v += 0.4;\n"; 169 return result.str(); 170 } 171 172 //! Used as the 'visit' argument for glslTraverseBasicTypes. 173 std::string glslCheckBasicTypeObject (const std::string& name, const glu::DataType type, const int indentationDepth) 174 { 175 const int scalarSize = glu::getDataTypeScalarSize(type); 176 const std::string indentation = std::string(indentationDepth, '\t'); 177 std::ostringstream result; 178 179 result << indentation << "allOk = allOk && compare_" << glu::getDataTypeName(type) << "(" << name << ", "; 180 181 if (type != glu::TYPE_FLOAT) 182 result << std::string() << glu::getDataTypeName(type) << "("; 183 for (int i = 0; i < scalarSize; ++i) 184 result << (i > 0 ? ", v+" + de::floatToString(0.8f*(float)i, 1) : "v"); 185 if (type != glu::TYPE_FLOAT) 186 result << ")"; 187 result << ");\n" 188 << indentation << "v += 0.4;\n" 189 << indentation << "if (allOk) ++firstFailedInputIndex;\n"; 190 191 return result.str(); 192 } 193 194 int numBasicSubobjectsInElementType (const std::vector<de::SharedPtr<TopLevelObject> >& objects) 195 { 196 int result = 0; 197 for (int i = 0; i < static_cast<int>(objects.size()); ++i) 198 result += objects[i]->numBasicSubobjectsInElementType(); 199 return result; 200 } 201 202 std::string basicSubobjectAtIndex (const int subobjectIndex, const std::vector<de::SharedPtr<TopLevelObject> >& objects, const int topLevelArraySize) 203 { 204 int currentIndex = 0; 205 int objectIndex = 0; 206 207 for (; currentIndex < subobjectIndex; ++objectIndex) 208 currentIndex += objects[objectIndex]->numBasicSubobjectsInElementType() * topLevelArraySize; 209 210 if (currentIndex > subobjectIndex) 211 { 212 --objectIndex; 213 currentIndex -= objects[objectIndex]->numBasicSubobjectsInElementType() * topLevelArraySize; 214 } 215 216 return objects[objectIndex]->basicSubobjectAtIndex(subobjectIndex - currentIndex, topLevelArraySize); 217 } 218 219 int numBasicSubobjects (const glu::VarType& type) 220 { 221 if (type.isBasicType()) 222 return 1; 223 else if (type.isArrayType()) 224 return type.getArraySize()*numBasicSubobjects(type.getElementType()); 225 else if (type.isStructType()) 226 { 227 const glu::StructType& structType = *type.getStructPtr(); 228 int result = 0; 229 for (int i = 0; i < structType.getNumMembers(); ++i) 230 result += numBasicSubobjects(structType.getMember(i).getType()); 231 return result; 232 } 233 else 234 { 235 DE_ASSERT(false); 236 return -1; 237 } 238 } 239 240 class Variable : public TopLevelObject 241 { 242 public: 243 Variable (const std::string& name_, const glu::VarType& type, const bool isArray) 244 : m_name (name_) 245 , m_type (type) 246 , m_isArray (isArray) 247 { 248 DE_ASSERT(!type.isArrayType()); 249 } 250 251 std::string name (void) const { return m_name; } 252 std::string declare (void) const; 253 std::string declareArray (const std::string& arraySizeExpr) const; 254 std::string glslTraverseBasicTypeArray (const int numArrayElements, const int indentationDepth, BasicTypeVisitFunc) const; 255 std::string glslTraverseBasicType (const int indentationDepth, BasicTypeVisitFunc) const; 256 int numBasicSubobjectsInElementType (void) const; 257 std::string basicSubobjectAtIndex (const int index, const int arraySize) const; 258 259 private: 260 std::string m_name; 261 glu::VarType m_type; //!< If this Variable is an array element, m_type is the element type; otherwise just the variable type. 262 const bool m_isArray; 263 }; 264 265 std::string Variable::declare (void) const 266 { 267 DE_ASSERT(!m_isArray); 268 return de::toString(glu::declare(m_type, m_name)) + ";\n"; 269 } 270 271 std::string Variable::declareArray (const std::string& sizeExpr) const 272 { 273 DE_ASSERT(m_isArray); 274 return de::toString(glu::declare(m_type, m_name)) + "[" + sizeExpr + "];\n"; 275 } 276 277 std::string Variable::glslTraverseBasicTypeArray (const int numArrayElements, const int indentationDepth, BasicTypeVisitFunc visit) const 278 { 279 DE_ASSERT(m_isArray); 280 281 const bool traverseAsArray = numArrayElements >= 0; 282 const std::string traversedName = m_name + (!traverseAsArray ? "[gl_InvocationID]" : ""); 283 const glu::VarType type = traverseAsArray ? glu::VarType(m_type, numArrayElements) : m_type; 284 285 return glslTraverseBasicTypes(traversedName, type, 0, indentationDepth, visit); 286 } 287 288 std::string Variable::glslTraverseBasicType (const int indentationDepth, BasicTypeVisitFunc visit) const 289 { 290 DE_ASSERT(!m_isArray); 291 return glslTraverseBasicTypes(m_name, m_type, 0, indentationDepth, visit); 292 } 293 294 int Variable::numBasicSubobjectsInElementType (void) const 295 { 296 return numBasicSubobjects(m_type); 297 } 298 299 std::string Variable::basicSubobjectAtIndex (const int subobjectIndex, const int arraySize) const 300 { 301 const glu::VarType type = m_isArray ? glu::VarType(m_type, arraySize) : m_type; 302 int currentIndex = 0; 303 304 for (glu::BasicTypeIterator basicIt = glu::BasicTypeIterator::begin(&type); basicIt != glu::BasicTypeIterator::end(&type); ++basicIt) 305 { 306 if (currentIndex == subobjectIndex) 307 return m_name + de::toString(glu::TypeAccessFormat(type, basicIt.getPath())); 308 ++currentIndex; 309 } 310 DE_ASSERT(false); 311 return DE_NULL; 312 } 313 314 class IOBlock : public TopLevelObject 315 { 316 public: 317 struct Member 318 { 319 std::string name; 320 glu::VarType type; 321 322 Member (const std::string& n, const glu::VarType& t) : name(n), type(t) {} 323 }; 324 325 IOBlock (const std::string& blockName, const std::string& interfaceName, const std::vector<Member>& members) 326 : m_blockName (blockName) 327 , m_interfaceName (interfaceName) 328 , m_members (members) 329 { 330 } 331 332 std::string name (void) const { return m_interfaceName; } 333 std::string declare (void) const; 334 std::string declareArray (const std::string& arraySizeExpr) const; 335 std::string glslTraverseBasicTypeArray (const int numArrayElements, const int indentationDepth, BasicTypeVisitFunc) const; 336 std::string glslTraverseBasicType (const int indentationDepth, BasicTypeVisitFunc) const; 337 int numBasicSubobjectsInElementType (void) const; 338 std::string basicSubobjectAtIndex (const int index, const int arraySize) const; 339 340 private: 341 std::string m_blockName; 342 std::string m_interfaceName; 343 std::vector<Member> m_members; 344 }; 345 346 std::string IOBlock::declare (void) const 347 { 348 std::ostringstream buf; 349 350 buf << m_blockName << "\n" 351 << "{\n"; 352 353 for (int i = 0; i < static_cast<int>(m_members.size()); ++i) 354 buf << "\t" << glu::declare(m_members[i].type, m_members[i].name) << ";\n"; 355 356 buf << "} " << m_interfaceName << ";\n"; 357 return buf.str(); 358 } 359 360 std::string IOBlock::declareArray (const std::string& sizeExpr) const 361 { 362 std::ostringstream buf; 363 364 buf << m_blockName << "\n" 365 << "{\n"; 366 367 for (int i = 0; i < static_cast<int>(m_members.size()); ++i) 368 buf << "\t" << glu::declare(m_members[i].type, m_members[i].name) << ";\n"; 369 370 buf << "} " << m_interfaceName << "[" << sizeExpr << "];\n"; 371 return buf.str(); 372 } 373 374 std::string IOBlock::glslTraverseBasicTypeArray (const int numArrayElements, const int indentationDepth, BasicTypeVisitFunc visit) const 375 { 376 if (numArrayElements >= 0) 377 { 378 const std::string indentation = std::string(indentationDepth, '\t'); 379 std::ostringstream result; 380 381 result << indentation << "for (int i0 = 0; i0 < " << numArrayElements << "; ++i0)\n" 382 << indentation << "{\n"; 383 for (int i = 0; i < static_cast<int>(m_members.size()); ++i) 384 result << glslTraverseBasicTypes(m_interfaceName + "[i0]." + m_members[i].name, m_members[i].type, 1, indentationDepth + 1, visit); 385 result << indentation + "}\n"; 386 return result.str(); 387 } 388 else 389 { 390 std::ostringstream result; 391 for (int i = 0; i < static_cast<int>(m_members.size()); ++i) 392 result << glslTraverseBasicTypes(m_interfaceName + "[gl_InvocationID]." + m_members[i].name, m_members[i].type, 0, indentationDepth, visit); 393 return result.str(); 394 } 395 } 396 397 std::string IOBlock::glslTraverseBasicType (const int indentationDepth, BasicTypeVisitFunc visit) const 398 { 399 std::ostringstream result; 400 for (int i = 0; i < static_cast<int>(m_members.size()); ++i) 401 result << glslTraverseBasicTypes(m_interfaceName + "." + m_members[i].name, m_members[i].type, 0, indentationDepth, visit); 402 return result.str(); 403 } 404 405 int IOBlock::numBasicSubobjectsInElementType (void) const 406 { 407 int result = 0; 408 for (int i = 0; i < static_cast<int>(m_members.size()); ++i) 409 result += numBasicSubobjects(m_members[i].type); 410 return result; 411 } 412 413 std::string IOBlock::basicSubobjectAtIndex (const int subobjectIndex, const int arraySize) const 414 { 415 int currentIndex = 0; 416 for (int arrayNdx = 0; arrayNdx < arraySize; ++arrayNdx) 417 for (int memberNdx = 0; memberNdx < static_cast<int>(m_members.size()); ++memberNdx) 418 { 419 const glu::VarType& membType = m_members[memberNdx].type; 420 for (glu::BasicTypeIterator basicIt = glu::BasicTypeIterator::begin(&membType); basicIt != glu::BasicTypeIterator::end(&membType); ++basicIt) 421 { 422 if (currentIndex == subobjectIndex) 423 return m_interfaceName + "[" + de::toString(arrayNdx) + "]." + m_members[memberNdx].name + de::toString(glu::TypeAccessFormat(membType, basicIt.getPath())); 424 currentIndex++; 425 } 426 } 427 DE_ASSERT(false); 428 return DE_NULL; 429 } 430 431 class UserDefinedIOTest : public TestCase 432 { 433 public: 434 UserDefinedIOTest (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const CaseDefinition caseDef); 435 void initPrograms (vk::SourceCollections& programCollection) const; 436 TestInstance* createInstance (Context& context) const; 437 438 private: 439 const CaseDefinition m_caseDef; 440 std::vector<glu::StructType> m_structTypes; 441 std::vector<de::SharedPtr<TopLevelObject> > m_tcsOutputs; 442 std::vector<de::SharedPtr<TopLevelObject> > m_tesInputs; 443 std::string m_tcsDeclarations; 444 std::string m_tcsStatements; 445 std::string m_tesDeclarations; 446 std::string m_tesStatements; 447 }; 448 449 UserDefinedIOTest::UserDefinedIOTest (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const CaseDefinition caseDef) 450 : TestCase (testCtx, name, description) 451 , m_caseDef (caseDef) 452 { 453 const bool isPerPatchIO = m_caseDef.ioType == IO_TYPE_PER_PATCH || 454 m_caseDef.ioType == IO_TYPE_PER_PATCH_ARRAY || 455 m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK || 456 m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK_ARRAY; 457 458 const bool isExplicitVertexArraySize = m_caseDef.vertexIOArraySize == VERTEX_IO_ARRAY_SIZE_EXPLICIT_SHADER_BUILTIN || 459 m_caseDef.vertexIOArraySize == VERTEX_IO_ARRAY_SIZE_EXPLICIT_SPEC_MIN; 460 461 const std::string vertexAttrArrayInputSize = m_caseDef.vertexIOArraySize == VERTEX_IO_ARRAY_SIZE_IMPLICIT ? "" 462 : m_caseDef.vertexIOArraySize == VERTEX_IO_ARRAY_SIZE_EXPLICIT_SHADER_BUILTIN ? "gl_MaxPatchVertices" 463 : m_caseDef.vertexIOArraySize == VERTEX_IO_ARRAY_SIZE_EXPLICIT_SPEC_MIN ? de::toString(MAX_TESSELLATION_PATCH_SIZE) 464 : DE_NULL; 465 466 const char* const maybePatch = isPerPatchIO ? "patch " : ""; 467 const std::string outMaybePatch = std::string() + maybePatch + "out "; 468 const std::string inMaybePatch = std::string() + maybePatch + "in "; 469 const bool useBlock = m_caseDef.ioType == IO_TYPE_PER_VERTEX_BLOCK || 470 m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK || 471 m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK_ARRAY; 472 const int wrongNumElements = -2; 473 474 std::ostringstream tcsDeclarations; 475 std::ostringstream tcsStatements; 476 std::ostringstream tesDeclarations; 477 std::ostringstream tesStatements; 478 479 // Indices 0 and 1 are taken, see initPrograms() 480 int tcsNextOutputLocation = 2; 481 int tesNextInputLocation = 2; 482 483 m_structTypes.push_back(glu::StructType("S")); 484 485 const glu::VarType highpFloat (glu::TYPE_FLOAT, glu::PRECISION_HIGHP); 486 glu::StructType& structType = m_structTypes.back(); 487 const glu::VarType structVarType (&structType); 488 bool usedStruct = false; 489 490 structType.addMember("x", glu::VarType(glu::TYPE_INT, glu::PRECISION_HIGHP)); 491 structType.addMember("y", glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP)); 492 493 // It is illegal to have a structure containing an array as an output variable 494 if (useBlock) 495 structType.addMember("z", glu::VarType(highpFloat, 2)); 496 497 if (useBlock) 498 { 499 std::vector<IOBlock::Member> blockMembers; 500 501 // use leaner block to make sure it is not larger than allowed (per-patch storage is very limited) 502 const bool useLightweightBlock = (m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK_ARRAY); 503 504 if (!useLightweightBlock) 505 blockMembers.push_back(IOBlock::Member("blockS", structVarType)); 506 507 blockMembers.push_back(IOBlock::Member("blockFa", glu::VarType(highpFloat, 3))); 508 blockMembers.push_back(IOBlock::Member("blockSa", glu::VarType(structVarType, 2))); 509 blockMembers.push_back(IOBlock::Member("blockF", highpFloat)); 510 511 m_tcsOutputs.push_back (de::SharedPtr<TopLevelObject>(new IOBlock("TheBlock", "tcBlock", blockMembers))); 512 m_tesInputs.push_back (de::SharedPtr<TopLevelObject>(new IOBlock("TheBlock", "teBlock", blockMembers))); 513 514 usedStruct = true; 515 } 516 else 517 { 518 const Variable var0("in_te_s", structVarType, m_caseDef.ioType != IO_TYPE_PER_PATCH); 519 const Variable var1("in_te_f", highpFloat, m_caseDef.ioType != IO_TYPE_PER_PATCH); 520 521 if (m_caseDef.ioType != IO_TYPE_PER_PATCH_ARRAY) 522 { 523 // Arrays of structures are disallowed, add struct cases only if not arrayed variable 524 m_tcsOutputs.push_back (de::SharedPtr<TopLevelObject>(new Variable(var0))); 525 m_tesInputs.push_back (de::SharedPtr<TopLevelObject>(new Variable(var0))); 526 527 usedStruct = true; 528 } 529 530 m_tcsOutputs.push_back (de::SharedPtr<TopLevelObject>(new Variable(var1))); 531 m_tesInputs.push_back (de::SharedPtr<TopLevelObject>(new Variable(var1))); 532 } 533 534 if (usedStruct) 535 tcsDeclarations << de::toString(glu::declare(structType)) + ";\n"; 536 537 tcsStatements << "\t{\n" 538 << "\t\thighp float v = 1.3;\n"; 539 540 for (int tcsOutputNdx = 0; tcsOutputNdx < static_cast<int>(m_tcsOutputs.size()); ++tcsOutputNdx) 541 { 542 const TopLevelObject& output = *m_tcsOutputs[tcsOutputNdx]; 543 const int numElements = !isPerPatchIO ? -1 //!< \note -1 means indexing with gl_InstanceID 544 : m_caseDef.ioType == IO_TYPE_PER_PATCH ? 1 545 : m_caseDef.ioType == IO_TYPE_PER_PATCH_ARRAY ? NUM_PER_PATCH_ARRAY_ELEMS 546 : m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK ? 1 547 : m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK_ARRAY ? NUM_PER_PATCH_BLOCKS 548 : wrongNumElements; 549 const bool isArray = (numElements != 1); 550 551 DE_ASSERT(numElements != wrongNumElements); 552 553 // \note: TCS output arrays are always implicitly-sized 554 tcsDeclarations << "layout(location = " << tcsNextOutputLocation << ") "; 555 if (isArray) 556 tcsDeclarations << outMaybePatch << output.declareArray(m_caseDef.ioType == IO_TYPE_PER_PATCH_ARRAY ? de::toString(NUM_PER_PATCH_ARRAY_ELEMS) 557 : m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK_ARRAY ? de::toString(NUM_PER_PATCH_BLOCKS) 558 : ""); 559 else 560 tcsDeclarations << outMaybePatch << output.declare(); 561 562 tcsNextOutputLocation += output.numBasicSubobjectsInElementType(); 563 564 if (!isPerPatchIO) 565 tcsStatements << "\t\tv += float(gl_InvocationID)*" << de::floatToString(0.4f * (float)output.numBasicSubobjectsInElementType(), 1) << ";\n"; 566 567 tcsStatements << "\n\t\t// Assign values to output " << output.name() << "\n"; 568 if (isArray) 569 tcsStatements << output.glslTraverseBasicTypeArray(numElements, 2, glslAssignBasicTypeObject); 570 else 571 tcsStatements << output.glslTraverseBasicType(2, glslAssignBasicTypeObject); 572 573 if (!isPerPatchIO) 574 tcsStatements << "\t\tv += float(" << de::toString(NUM_OUTPUT_VERTICES) << "-gl_InvocationID-1)*" << de::floatToString(0.4f * (float)output.numBasicSubobjectsInElementType(), 1) << ";\n"; 575 } 576 tcsStatements << "\t}\n"; 577 578 tcsDeclarations << "\n" 579 << "layout(location = 0) in " + Variable("in_tc_attr", highpFloat, true).declareArray(vertexAttrArrayInputSize); 580 581 if (usedStruct) 582 tesDeclarations << de::toString(glu::declare(structType)) << ";\n"; 583 584 tesStatements << "\tbool allOk = true;\n" 585 << "\thighp uint firstFailedInputIndex = 0u;\n" 586 << "\t{\n" 587 << "\t\thighp float v = 1.3;\n"; 588 589 for (int tesInputNdx = 0; tesInputNdx < static_cast<int>(m_tesInputs.size()); ++tesInputNdx) 590 { 591 const TopLevelObject& input = *m_tesInputs[tesInputNdx]; 592 const int numElements = !isPerPatchIO ? NUM_OUTPUT_VERTICES 593 : m_caseDef.ioType == IO_TYPE_PER_PATCH ? 1 594 : m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK ? 1 595 : m_caseDef.ioType == IO_TYPE_PER_PATCH_ARRAY ? NUM_PER_PATCH_ARRAY_ELEMS 596 : m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK_ARRAY ? NUM_PER_PATCH_BLOCKS 597 : wrongNumElements; 598 const bool isArray = (numElements != 1); 599 600 DE_ASSERT(numElements != wrongNumElements); 601 602 tesDeclarations << "layout(location = " << tesNextInputLocation << ") "; 603 if (isArray) 604 tesDeclarations << inMaybePatch << input.declareArray(m_caseDef.ioType == IO_TYPE_PER_PATCH_ARRAY ? de::toString(NUM_PER_PATCH_ARRAY_ELEMS) 605 : m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK_ARRAY ? de::toString(NUM_PER_PATCH_BLOCKS) 606 : isExplicitVertexArraySize ? de::toString(vertexAttrArrayInputSize) 607 : ""); 608 else 609 tesDeclarations << inMaybePatch + input.declare(); 610 611 tesNextInputLocation += input.numBasicSubobjectsInElementType(); 612 613 tesStatements << "\n\t\t// Check values in input " << input.name() << "\n"; 614 if (isArray) 615 tesStatements << input.glslTraverseBasicTypeArray(numElements, 2, glslCheckBasicTypeObject); 616 else 617 tesStatements << input.glslTraverseBasicType(2, glslCheckBasicTypeObject); 618 } 619 tesStatements << "\t}\n"; 620 621 m_tcsDeclarations = tcsDeclarations.str(); 622 m_tcsStatements = tcsStatements.str(); 623 m_tesDeclarations = tesDeclarations.str(); 624 m_tesStatements = tesStatements.str(); 625 } 626 627 void UserDefinedIOTest::initPrograms (vk::SourceCollections& programCollection) const 628 { 629 // Vertex shader 630 { 631 std::ostringstream src; 632 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 633 << "\n" 634 << "layout(location = 0) in highp float in_v_attr;\n" 635 << "layout(location = 0) out highp float in_tc_attr;\n" 636 << "\n" 637 << "void main (void)\n" 638 << "{\n" 639 << " in_tc_attr = in_v_attr;\n" 640 << "}\n"; 641 642 programCollection.glslSources.add("vert") << glu::VertexSource(src.str()); 643 } 644 645 // Tessellation control shader 646 { 647 std::ostringstream src; 648 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 649 << "#extension GL_EXT_tessellation_shader : require\n" 650 << "\n" 651 << "layout(vertices = " << NUM_OUTPUT_VERTICES << ") out;\n" 652 << "\n" 653 << "layout(location = 0) patch out highp vec2 in_te_positionScale;\n" 654 << "layout(location = 1) patch out highp vec2 in_te_positionOffset;\n" 655 << "\n" 656 << m_tcsDeclarations 657 << "\n" 658 << "void main (void)\n" 659 << "{\n" 660 << m_tcsStatements 661 << "\n" 662 << " gl_TessLevelInner[0] = in_tc_attr[0];\n" 663 << " gl_TessLevelInner[1] = in_tc_attr[1];\n" 664 << "\n" 665 << " gl_TessLevelOuter[0] = in_tc_attr[2];\n" 666 << " gl_TessLevelOuter[1] = in_tc_attr[3];\n" 667 << " gl_TessLevelOuter[2] = in_tc_attr[4];\n" 668 << " gl_TessLevelOuter[3] = in_tc_attr[5];\n" 669 << "\n" 670 << " in_te_positionScale = vec2(in_tc_attr[6], in_tc_attr[7]);\n" 671 << " in_te_positionOffset = vec2(in_tc_attr[8], in_tc_attr[9]);\n" 672 << "}\n"; 673 674 programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()); 675 } 676 677 // Tessellation evaluation shader 678 { 679 std::ostringstream src; 680 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 681 << "#extension GL_EXT_tessellation_shader : require\n" 682 << "\n" 683 << "layout(" << getTessPrimitiveTypeShaderName(m_caseDef.primitiveType) << ") in;\n" 684 << "\n" 685 << "layout(location = 0) patch in highp vec2 in_te_positionScale;\n" 686 << "layout(location = 1) patch in highp vec2 in_te_positionOffset;\n" 687 << "\n" 688 << m_tesDeclarations 689 << "\n" 690 << "layout(location = 0) out highp vec4 in_f_color;\n" 691 << "\n" 692 << "// Will contain the index of the first incorrect input,\n" 693 << "// or the number of inputs if all are correct\n" 694 << "layout (set = 0, binding = 0, std430) coherent restrict buffer Output {\n" 695 << " int numInvocations;\n" 696 << " uint firstFailedInputIndex[];\n" 697 << "} sb_out;\n" 698 << "\n" 699 << "bool compare_int (int a, int b) { return a == b; }\n" 700 << "bool compare_float (float a, float b) { return abs(a - b) < 0.01f; }\n" 701 << "bool compare_vec4 (vec4 a, vec4 b) { return all(lessThan(abs(a - b), vec4(0.01f))); }\n" 702 << "\n" 703 << "void main (void)\n" 704 << "{\n" 705 << m_tesStatements 706 << "\n" 707 << " gl_Position = vec4(gl_TessCoord.xy*in_te_positionScale + in_te_positionOffset, 0.0, 1.0);\n" 708 << " in_f_color = allOk ? vec4(0.0, 1.0, 0.0, 1.0)\n" 709 << " : vec4(1.0, 0.0, 0.0, 1.0);\n" 710 << "\n" 711 << " int index = atomicAdd(sb_out.numInvocations, 1);\n" 712 << " sb_out.firstFailedInputIndex[index] = firstFailedInputIndex;\n" 713 << "}\n"; 714 715 programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()); 716 } 717 718 // Fragment shader 719 { 720 std::ostringstream src; 721 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 722 << "\n" 723 << "layout(location = 0) in highp vec4 in_f_color;\n" 724 << "layout(location = 0) out mediump vec4 o_color;\n" 725 << "\n" 726 << "void main (void)\n" 727 << "{\n" 728 << " o_color = in_f_color;\n" 729 << "}\n"; 730 731 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()); 732 } 733 } 734 735 class UserDefinedIOTestInstance : public TestInstance 736 { 737 public: 738 UserDefinedIOTestInstance (Context& context, 739 const CaseDefinition caseDef, 740 const std::vector<de::SharedPtr<TopLevelObject> >& tesInputs); 741 tcu::TestStatus iterate (void); 742 743 private: 744 const CaseDefinition m_caseDef; 745 const std::vector<de::SharedPtr<TopLevelObject> > m_tesInputs; 746 }; 747 748 UserDefinedIOTestInstance::UserDefinedIOTestInstance (Context& context, const CaseDefinition caseDef, const std::vector<de::SharedPtr<TopLevelObject> >& tesInputs) 749 : TestInstance (context) 750 , m_caseDef (caseDef) 751 , m_tesInputs (tesInputs) 752 { 753 } 754 755 tcu::TestStatus UserDefinedIOTestInstance::iterate (void) 756 { 757 requireFeatures(m_context.getInstanceInterface(), m_context.getPhysicalDevice(), FEATURE_TESSELLATION_SHADER | FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS); 758 759 const DeviceInterface& vk = m_context.getDeviceInterface(); 760 const VkDevice device = m_context.getDevice(); 761 const VkQueue queue = m_context.getUniversalQueue(); 762 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); 763 Allocator& allocator = m_context.getDefaultAllocator(); 764 765 const int numAttributes = NUM_TESS_LEVELS + 2 + 2; 766 static const float attributes[numAttributes] = { /* inner */ 3.0f, 4.0f, /* outer */ 5.0f, 6.0f, 7.0f, 8.0f, /* pos. scale */ 1.2f, 1.3f, /* pos. offset */ -0.3f, -0.4f }; 767 const int refNumVertices = referenceVertexCount(m_caseDef.primitiveType, SPACINGMODE_EQUAL, false, &attributes[0], &attributes[2]); 768 const int refNumUniqueVertices = referenceVertexCount(m_caseDef.primitiveType, SPACINGMODE_EQUAL, true, &attributes[0], &attributes[2]); 769 770 // Vertex input attributes buffer: to pass tessellation levels 771 772 const VkFormat vertexFormat = VK_FORMAT_R32_SFLOAT; 773 const deUint32 vertexStride = tcu::getPixelSize(mapVkFormat(vertexFormat)); 774 const VkDeviceSize vertexDataSizeBytes = numAttributes * vertexStride; 775 const Buffer vertexBuffer (vk, device, allocator, makeBufferCreateInfo(vertexDataSizeBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible); 776 777 { 778 const Allocation& alloc = vertexBuffer.getAllocation(); 779 deMemcpy(alloc.getHostPtr(), &attributes[0], static_cast<std::size_t>(vertexDataSizeBytes)); 780 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), vertexDataSizeBytes); 781 } 782 783 // Output buffer: number of invocations and verification indices 784 785 const int resultBufferMaxVertices = refNumVertices; 786 const VkDeviceSize resultBufferSizeBytes = sizeof(deInt32) + resultBufferMaxVertices * sizeof(deUint32); 787 const Buffer resultBuffer (vk, device, allocator, makeBufferCreateInfo(resultBufferSizeBytes, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible); 788 789 { 790 const Allocation& alloc = resultBuffer.getAllocation(); 791 deMemset(alloc.getHostPtr(), 0, static_cast<std::size_t>(resultBufferSizeBytes)); 792 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), resultBufferSizeBytes); 793 } 794 795 // Color attachment 796 797 const tcu::IVec2 renderSize = tcu::IVec2(RENDER_SIZE, RENDER_SIZE); 798 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM; 799 const VkImageSubresourceRange colorImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u); 800 const Image colorAttachmentImage (vk, device, allocator, 801 makeImageCreateInfo(renderSize, colorFormat, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 1u), 802 MemoryRequirement::Any); 803 804 // Color output buffer: image will be copied here for verification 805 806 const VkDeviceSize colorBufferSizeBytes = renderSize.x()*renderSize.y() * tcu::getPixelSize(mapVkFormat(colorFormat)); 807 const Buffer colorBuffer (vk, device, allocator, makeBufferCreateInfo(colorBufferSizeBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible); 808 809 // Descriptors 810 811 const Unique<VkDescriptorSetLayout> descriptorSetLayout(DescriptorSetLayoutBuilder() 812 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) 813 .build(vk, device)); 814 815 const Unique<VkDescriptorPool> descriptorPool(DescriptorPoolBuilder() 816 .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) 817 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u)); 818 819 const Unique<VkDescriptorSet> descriptorSet (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout)); 820 const VkDescriptorBufferInfo resultBufferInfo = makeDescriptorBufferInfo(resultBuffer.get(), 0ull, resultBufferSizeBytes); 821 822 DescriptorSetUpdateBuilder() 823 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultBufferInfo) 824 .update(vk, device); 825 826 // Pipeline 827 828 const Unique<VkImageView> colorAttachmentView(makeImageView(vk, device, *colorAttachmentImage, VK_IMAGE_VIEW_TYPE_2D, colorFormat, colorImageSubresourceRange)); 829 const Unique<VkRenderPass> renderPass (makeRenderPass(vk, device, colorFormat)); 830 const Unique<VkFramebuffer> framebuffer (makeFramebuffer(vk, device, *renderPass, *colorAttachmentView, renderSize.x(), renderSize.y(), 1u)); 831 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout)); 832 const Unique<VkCommandPool> cmdPool (makeCommandPool(vk, device, queueFamilyIndex)); 833 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer (vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 834 835 const Unique<VkPipeline> pipeline(GraphicsPipelineBuilder() 836 .setRenderSize (renderSize) 837 .setPatchControlPoints (numAttributes) 838 .setVertexInputSingleAttribute(vertexFormat, vertexStride) 839 .setShader (vk, device, VK_SHADER_STAGE_VERTEX_BIT, m_context.getBinaryCollection().get("vert"), DE_NULL) 840 .setShader (vk, device, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, m_context.getBinaryCollection().get("tesc"), DE_NULL) 841 .setShader (vk, device, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, m_context.getBinaryCollection().get("tese"), DE_NULL) 842 .setShader (vk, device, VK_SHADER_STAGE_FRAGMENT_BIT, m_context.getBinaryCollection().get("frag"), DE_NULL) 843 .build (vk, device, *pipelineLayout, *renderPass)); 844 845 // Begin draw 846 847 beginCommandBuffer(vk, *cmdBuffer); 848 849 // Change color attachment image layout 850 { 851 const VkImageMemoryBarrier colorAttachmentLayoutBarrier = makeImageMemoryBarrier( 852 (VkAccessFlags)0, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 853 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 854 *colorAttachmentImage, colorImageSubresourceRange); 855 856 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0u, 857 0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentLayoutBarrier); 858 } 859 860 { 861 const VkRect2D renderArea = { 862 makeOffset2D(0, 0), 863 makeExtent2D(renderSize.x(), renderSize.y()), 864 }; 865 const tcu::Vec4 clearColor(0.0f, 0.0f, 0.0f, 1.0f); 866 867 beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderArea, clearColor); 868 } 869 870 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline); 871 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL); 872 { 873 const VkDeviceSize vertexBufferOffset = 0ull; 874 vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset); 875 } 876 877 vk.cmdDraw(*cmdBuffer, numAttributes, 1u, 0u, 0u); 878 endRenderPass(vk, *cmdBuffer); 879 880 // Copy render result to a host-visible buffer 881 { 882 const VkImageMemoryBarrier colorAttachmentPreCopyBarrier = makeImageMemoryBarrier( 883 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, 884 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 885 *colorAttachmentImage, colorImageSubresourceRange); 886 887 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 888 0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentPreCopyBarrier); 889 } 890 { 891 const VkBufferImageCopy copyRegion = makeBufferImageCopy(makeExtent3D(renderSize.x(), renderSize.y(), 1), makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u)); 892 vk.cmdCopyImageToBuffer(*cmdBuffer, *colorAttachmentImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *colorBuffer, 1u, ©Region); 893 } 894 { 895 const VkBufferMemoryBarrier postCopyBarrier = makeBufferMemoryBarrier( 896 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *colorBuffer, 0ull, colorBufferSizeBytes); 897 898 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 899 0u, DE_NULL, 1u, &postCopyBarrier, 0u, DE_NULL); 900 } 901 902 endCommandBuffer(vk, *cmdBuffer); 903 submitCommandsAndWait(vk, device, queue, *cmdBuffer); 904 905 // Verification 906 907 bool isImageCompareOK = false; 908 { 909 const Allocation& colorBufferAlloc = colorBuffer.getAllocation(); 910 invalidateMappedMemoryRange(vk, device, colorBufferAlloc.getMemory(), colorBufferAlloc.getOffset(), colorBufferSizeBytes); 911 912 // Load reference image 913 tcu::TextureLevel referenceImage; 914 tcu::ImageIO::loadPNG(referenceImage, m_context.getTestContext().getArchive(), m_caseDef.referenceImagePath.c_str()); 915 916 // Verify case result 917 const tcu::ConstPixelBufferAccess resultImageAccess(mapVkFormat(colorFormat), renderSize.x(), renderSize.y(), 1, colorBufferAlloc.getHostPtr()); 918 isImageCompareOK = tcu::fuzzyCompare(m_context.getTestContext().getLog(), "ImageComparison", "Image Comparison", 919 referenceImage.getAccess(), resultImageAccess, 0.02f, tcu::COMPARE_LOG_RESULT); 920 } 921 { 922 const Allocation& resultAlloc = resultBuffer.getAllocation(); 923 invalidateMappedMemoryRange(vk, device, resultAlloc.getMemory(), resultAlloc.getOffset(), resultBufferSizeBytes); 924 925 const deInt32 numVertices = *static_cast<deInt32*>(resultAlloc.getHostPtr()); 926 const deUint32* const vertices = reinterpret_cast<deUint32*>(static_cast<deUint8*>(resultAlloc.getHostPtr()) + sizeof(deInt32)); 927 928 // If this fails then we didn't read all vertices from shader and test must be changed to allow more. 929 DE_ASSERT(numVertices <= refNumVertices); 930 931 if (numVertices < refNumUniqueVertices) 932 { 933 m_context.getTestContext().getLog() 934 << tcu::TestLog::Message << "Failure: got " << numVertices << " vertices, but expected at least " << refNumUniqueVertices << tcu::TestLog::EndMessage; 935 936 return tcu::TestStatus::fail("Wrong number of vertices"); 937 } 938 else 939 { 940 tcu::TestLog& log = m_context.getTestContext().getLog(); 941 const int topLevelArraySize = (m_caseDef.ioType == IO_TYPE_PER_PATCH ? 1 942 : m_caseDef.ioType == IO_TYPE_PER_PATCH_ARRAY ? NUM_PER_PATCH_ARRAY_ELEMS 943 : m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK ? 1 944 : m_caseDef.ioType == IO_TYPE_PER_PATCH_BLOCK_ARRAY ? NUM_PER_PATCH_BLOCKS 945 : NUM_OUTPUT_VERTICES); 946 const deUint32 numTEInputs = numBasicSubobjectsInElementType(m_tesInputs) * topLevelArraySize; 947 948 for (int vertexNdx = 0; vertexNdx < numVertices; ++vertexNdx) 949 if (vertices[vertexNdx] > numTEInputs) 950 { 951 log << tcu::TestLog::Message 952 << "Failure: out_te_firstFailedInputIndex has value " << vertices[vertexNdx] 953 << ", but should be in range [0, " << numTEInputs << "]" << tcu::TestLog::EndMessage; 954 955 return tcu::TestStatus::fail("Invalid values returned from shader"); 956 } 957 else if (vertices[vertexNdx] != numTEInputs) 958 { 959 log << tcu::TestLog::Message << "Failure: in tessellation evaluation shader, check for input " 960 << basicSubobjectAtIndex(vertices[vertexNdx], m_tesInputs, topLevelArraySize) << " failed" << tcu::TestLog::EndMessage; 961 962 return tcu::TestStatus::fail("Invalid input value in tessellation evaluation shader"); 963 } 964 } 965 } 966 return (isImageCompareOK ? tcu::TestStatus::pass("OK") : tcu::TestStatus::fail("Image comparison failed")); 967 } 968 969 TestInstance* UserDefinedIOTest::createInstance (Context& context) const 970 { 971 return new UserDefinedIOTestInstance(context, m_caseDef, m_tesInputs); 972 } 973 974 } // anonymous 975 976 //! These tests correspond roughly to dEQP-GLES31.functional.tessellation.user_defined_io.* 977 //! Original GLES test queried maxTessellationPatchSize, but this can't be done at the stage the shader source is prepared. 978 //! Instead, we use minimum supported value. 979 //! Negative tests weren't ported because vktShaderLibrary doesn't support tests that are expected to fail shader compilation. 980 tcu::TestCaseGroup* createUserDefinedIOTests (tcu::TestContext& testCtx) 981 { 982 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "user_defined_io", "Test non-built-in per-patch and per-vertex inputs and outputs")); 983 984 static const struct 985 { 986 const char* name; 987 const char* description; 988 IOType ioType; 989 } ioCases[] = 990 { 991 { "per_patch", "Per-patch TCS outputs", IO_TYPE_PER_PATCH }, 992 { "per_patch_array", "Per-patch array TCS outputs", IO_TYPE_PER_PATCH_ARRAY }, 993 { "per_patch_block", "Per-patch TCS outputs in IO block", IO_TYPE_PER_PATCH_BLOCK }, 994 { "per_patch_block_array", "Per-patch TCS outputs in IO block array", IO_TYPE_PER_PATCH_BLOCK_ARRAY }, 995 { "per_vertex", "Per-vertex TCS outputs", IO_TYPE_PER_VERTEX }, 996 { "per_vertex_block", "Per-vertex TCS outputs in IO block", IO_TYPE_PER_VERTEX_BLOCK }, 997 }; 998 999 static const struct 1000 { 1001 const char* name; 1002 VertexIOArraySize vertexIOArraySize; 1003 } vertexArraySizeCases[] = 1004 { 1005 { "vertex_io_array_size_implicit", VERTEX_IO_ARRAY_SIZE_IMPLICIT }, 1006 { "vertex_io_array_size_shader_builtin", VERTEX_IO_ARRAY_SIZE_EXPLICIT_SHADER_BUILTIN }, 1007 { "vertex_io_array_size_spec_min", VERTEX_IO_ARRAY_SIZE_EXPLICIT_SPEC_MIN }, 1008 }; 1009 1010 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(ioCases); ++caseNdx) 1011 { 1012 de::MovePtr<tcu::TestCaseGroup> ioTypeGroup (new tcu::TestCaseGroup(testCtx, ioCases[caseNdx].name, ioCases[caseNdx].description)); 1013 for (int arrayCaseNdx = 0; arrayCaseNdx < DE_LENGTH_OF_ARRAY(vertexArraySizeCases); ++arrayCaseNdx) 1014 { 1015 de::MovePtr<tcu::TestCaseGroup> vertexArraySizeGroup (new tcu::TestCaseGroup(testCtx, vertexArraySizeCases[arrayCaseNdx].name, "")); 1016 for (int primitiveTypeNdx = 0; primitiveTypeNdx < TESSPRIMITIVETYPE_LAST; ++primitiveTypeNdx) 1017 { 1018 const TessPrimitiveType primitiveType = static_cast<TessPrimitiveType>(primitiveTypeNdx); 1019 const std::string primitiveName = getTessPrimitiveTypeShaderName(primitiveType); 1020 const CaseDefinition caseDef = { primitiveType, ioCases[caseNdx].ioType, vertexArraySizeCases[arrayCaseNdx].vertexIOArraySize, 1021 std::string() + "vulkan/data/tessellation/user_defined_io_" + primitiveName + "_ref.png" }; 1022 1023 vertexArraySizeGroup->addChild(new UserDefinedIOTest(testCtx, primitiveName, "", caseDef)); 1024 } 1025 ioTypeGroup->addChild(vertexArraySizeGroup.release()); 1026 } 1027 group->addChild(ioTypeGroup.release()); 1028 } 1029 1030 return group.release(); 1031 } 1032 1033 } // tessellation 1034 } // vkt 1035
