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 Coordinates Tests 23 *//*--------------------------------------------------------------------*/ 24 25 #include "vktTessellationCoordinatesTests.hpp" 26 #include "vktTestCaseUtil.hpp" 27 #include "vktTessellationUtil.hpp" 28 29 #include "tcuTestLog.hpp" 30 #include "tcuRGBA.hpp" 31 #include "tcuSurface.hpp" 32 #include "tcuTextureUtil.hpp" 33 #include "tcuVectorUtil.hpp" 34 35 #include "vkDefs.hpp" 36 #include "vkQueryUtil.hpp" 37 #include "vkBuilderUtil.hpp" 38 #include "vkTypeUtil.hpp" 39 40 #include "deUniquePtr.hpp" 41 42 #include <string> 43 #include <vector> 44 45 namespace vkt 46 { 47 namespace tessellation 48 { 49 50 using namespace vk; 51 52 namespace 53 { 54 55 template <typename T> 56 class SizeLessThan 57 { 58 public: 59 bool operator() (const T& a, const T& b) const { return a.size() < b.size(); } 60 }; 61 62 std::string getCaseName (const TessPrimitiveType primitiveType, const SpacingMode spacingMode) 63 { 64 std::ostringstream str; 65 str << getTessPrimitiveTypeShaderName(primitiveType) << "_" << getSpacingModeShaderName(spacingMode); 66 return str.str(); 67 } 68 69 std::vector<TessLevels> genTessLevelCases (const TessPrimitiveType primitiveType, 70 const SpacingMode spacingMode) 71 { 72 static const TessLevels rawTessLevelCases[] = 73 { 74 { { 1.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f } }, 75 { { 63.0f, 24.0f }, { 15.0f, 42.0f, 10.0f, 12.0f } }, 76 { { 3.0f, 2.0f }, { 6.0f, 8.0f, 7.0f, 9.0f } }, 77 { { 4.0f, 6.0f }, { 2.0f, 3.0f, 1.0f, 4.0f } }, 78 { { 2.0f, 2.0f }, { 6.0f, 8.0f, 7.0f, 9.0f } }, 79 { { 5.0f, 6.0f }, { 1.0f, 1.0f, 1.0f, 1.0f } }, 80 { { 1.0f, 6.0f }, { 2.0f, 3.0f, 1.0f, 4.0f } }, 81 { { 5.0f, 1.0f }, { 2.0f, 3.0f, 1.0f, 4.0f } }, 82 { { 5.2f, 1.6f }, { 2.9f, 3.4f, 1.5f, 4.1f } } 83 }; 84 85 if (spacingMode == SPACINGMODE_EQUAL) 86 return std::vector<TessLevels>(DE_ARRAY_BEGIN(rawTessLevelCases), DE_ARRAY_END(rawTessLevelCases)); 87 else 88 { 89 std::vector<TessLevels> result; 90 result.reserve(DE_LENGTH_OF_ARRAY(rawTessLevelCases)); 91 92 for (int tessLevelCaseNdx = 0; tessLevelCaseNdx < DE_LENGTH_OF_ARRAY(rawTessLevelCases); ++tessLevelCaseNdx) 93 { 94 TessLevels curTessLevelCase = rawTessLevelCases[tessLevelCaseNdx]; 95 96 float* const inner = &curTessLevelCase.inner[0]; 97 float* const outer = &curTessLevelCase.outer[0]; 98 99 for (int j = 0; j < 2; ++j) inner[j] = static_cast<float>(getClampedRoundedTessLevel(spacingMode, inner[j])); 100 for (int j = 0; j < 4; ++j) outer[j] = static_cast<float>(getClampedRoundedTessLevel(spacingMode, outer[j])); 101 102 if (primitiveType == TESSPRIMITIVETYPE_TRIANGLES) 103 { 104 if (outer[0] > 1.0f || outer[1] > 1.0f || outer[2] > 1.0f) 105 { 106 if (inner[0] == 1.0f) 107 inner[0] = static_cast<float>(getClampedRoundedTessLevel(spacingMode, inner[0] + 0.1f)); 108 } 109 } 110 else if (primitiveType == TESSPRIMITIVETYPE_QUADS) 111 { 112 if (outer[0] > 1.0f || outer[1] > 1.0f || outer[2] > 1.0f || outer[3] > 1.0f) 113 { 114 if (inner[0] == 1.0f) inner[0] = static_cast<float>(getClampedRoundedTessLevel(spacingMode, inner[0] + 0.1f)); 115 if (inner[1] == 1.0f) inner[1] = static_cast<float>(getClampedRoundedTessLevel(spacingMode, inner[1] + 0.1f)); 116 } 117 } 118 119 result.push_back(curTessLevelCase); 120 } 121 122 DE_ASSERT(static_cast<int>(result.size()) == DE_LENGTH_OF_ARRAY(rawTessLevelCases)); 123 return result; 124 } 125 } 126 127 std::vector<tcu::Vec3> generateReferenceTessCoords (const TessPrimitiveType primitiveType, 128 const SpacingMode spacingMode, 129 const float* innerLevels, 130 const float* outerLevels) 131 { 132 if (isPatchDiscarded(primitiveType, outerLevels)) 133 return std::vector<tcu::Vec3>(); 134 135 switch (primitiveType) 136 { 137 case TESSPRIMITIVETYPE_TRIANGLES: 138 { 139 int inner; 140 int outer[3]; 141 getClampedRoundedTriangleTessLevels(spacingMode, innerLevels, outerLevels, &inner, &outer[0]); 142 143 if (spacingMode != SPACINGMODE_EQUAL) 144 { 145 // \note For fractional spacing modes, exact results are implementation-defined except in special cases. 146 DE_ASSERT(de::abs(innerLevels[0] - static_cast<float>(inner)) < 0.001f); 147 for (int i = 0; i < 3; ++i) 148 DE_ASSERT(de::abs(outerLevels[i] - static_cast<float>(outer[i])) < 0.001f); 149 DE_ASSERT(inner > 1 || (outer[0] == 1 && outer[1] == 1 && outer[2] == 1)); 150 } 151 152 return generateReferenceTriangleTessCoords(spacingMode, inner, outer[0], outer[1], outer[2]); 153 } 154 155 case TESSPRIMITIVETYPE_QUADS: 156 { 157 int inner[2]; 158 int outer[4]; 159 getClampedRoundedQuadTessLevels(spacingMode, innerLevels, outerLevels, &inner[0], &outer[0]); 160 161 if (spacingMode != SPACINGMODE_EQUAL) 162 { 163 // \note For fractional spacing modes, exact results are implementation-defined except in special cases. 164 for (int i = 0; i < 2; ++i) 165 DE_ASSERT(de::abs(innerLevels[i] - static_cast<float>(inner[i])) < 0.001f); 166 for (int i = 0; i < 4; ++i) 167 DE_ASSERT(de::abs(outerLevels[i] - static_cast<float>(outer[i])) < 0.001f); 168 169 DE_ASSERT((inner[0] > 1 && inner[1] > 1) || (inner[0] == 1 && inner[1] == 1 && outer[0] == 1 && outer[1] == 1 && outer[2] == 1 && outer[3] == 1)); 170 } 171 172 return generateReferenceQuadTessCoords(spacingMode, inner[0], inner[1], outer[0], outer[1], outer[2], outer[3]); 173 } 174 175 case TESSPRIMITIVETYPE_ISOLINES: 176 { 177 int outer[2]; 178 getClampedRoundedIsolineTessLevels(spacingMode, &outerLevels[0], &outer[0]); 179 180 if (spacingMode != SPACINGMODE_EQUAL) 181 { 182 // \note For fractional spacing modes, exact results are implementation-defined except in special cases. 183 DE_ASSERT(de::abs(outerLevels[1] - static_cast<float>(outer[1])) < 0.001f); 184 } 185 186 return generateReferenceIsolineTessCoords(outer[0], outer[1]); 187 } 188 189 default: 190 DE_ASSERT(false); 191 return std::vector<tcu::Vec3>(); 192 } 193 } 194 195 void drawPoint (tcu::Surface& dst, const int centerX, const int centerY, const tcu::RGBA& color, const int size) 196 { 197 const int width = dst.getWidth(); 198 const int height = dst.getHeight(); 199 DE_ASSERT(de::inBounds(centerX, 0, width) && de::inBounds(centerY, 0, height)); 200 DE_ASSERT(size > 0); 201 202 for (int yOff = -((size-1)/2); yOff <= size/2; ++yOff) 203 for (int xOff = -((size-1)/2); xOff <= size/2; ++xOff) 204 { 205 const int pixX = centerX + xOff; 206 const int pixY = centerY + yOff; 207 if (de::inBounds(pixX, 0, width) && de::inBounds(pixY, 0, height)) 208 dst.setPixel(pixX, pixY, color); 209 } 210 } 211 212 void drawTessCoordPoint (tcu::Surface& dst, const TessPrimitiveType primitiveType, const tcu::Vec3& pt, const tcu::RGBA& color, const int size) 213 { 214 // \note These coordinates should match the description in the log message in TessCoordTestInstance::iterate. 215 216 static const tcu::Vec2 triangleCorners[3] = 217 { 218 tcu::Vec2(0.95f, 0.95f), 219 tcu::Vec2(0.5f, 0.95f - 0.9f*deFloatSqrt(3.0f/4.0f)), 220 tcu::Vec2(0.05f, 0.95f) 221 }; 222 223 static const float quadIsolineLDRU[4] = 224 { 225 0.1f, 0.9f, 0.9f, 0.1f 226 }; 227 228 const tcu::Vec2 dstPos = primitiveType == TESSPRIMITIVETYPE_TRIANGLES ? pt.x()*triangleCorners[0] 229 + pt.y()*triangleCorners[1] 230 + pt.z()*triangleCorners[2] 231 232 : primitiveType == TESSPRIMITIVETYPE_QUADS || 233 primitiveType == TESSPRIMITIVETYPE_ISOLINES ? tcu::Vec2((1.0f - pt.x())*quadIsolineLDRU[0] + pt.x()*quadIsolineLDRU[2], 234 (1.0f - pt.y())*quadIsolineLDRU[1] + pt.y()*quadIsolineLDRU[3]) 235 236 : tcu::Vec2(-1.0f); 237 238 drawPoint(dst, 239 static_cast<int>(dstPos.x() * (float)dst.getWidth()), 240 static_cast<int>(dstPos.y() * (float)dst.getHeight()), 241 color, 242 size); 243 } 244 245 void drawTessCoordVisualization (tcu::Surface& dst, const TessPrimitiveType primitiveType, const std::vector<tcu::Vec3>& coords) 246 { 247 const int imageWidth = 256; 248 const int imageHeight = 256; 249 dst.setSize(imageWidth, imageHeight); 250 251 tcu::clear(dst.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)); 252 253 for (int i = 0; i < static_cast<int>(coords.size()); ++i) 254 drawTessCoordPoint(dst, primitiveType, coords[i], tcu::RGBA::white(), 2); 255 } 256 257 inline bool vec3XLessThan (const tcu::Vec3& a, const tcu::Vec3& b) 258 { 259 return a.x() < b.x(); 260 } 261 262 int binarySearchFirstVec3WithXAtLeast (const std::vector<tcu::Vec3>& sorted, float x) 263 { 264 const tcu::Vec3 ref(x, 0.0f, 0.0f); 265 const std::vector<tcu::Vec3>::const_iterator first = std::lower_bound(sorted.begin(), sorted.end(), ref, vec3XLessThan); 266 if (first == sorted.end()) 267 return -1; 268 return static_cast<int>(std::distance(sorted.begin(), first)); 269 } 270 271 // Check that all points in subset are (approximately) present also in superset. 272 bool oneWayComparePointSets (tcu::TestLog& log, 273 tcu::Surface& errorDst, 274 const TessPrimitiveType primitiveType, 275 const std::vector<tcu::Vec3>& subset, 276 const std::vector<tcu::Vec3>& superset, 277 const char* subsetName, 278 const char* supersetName, 279 const tcu::RGBA& errorColor) 280 { 281 const std::vector<tcu::Vec3> supersetSorted = sorted(superset, vec3XLessThan); 282 const float epsilon = 0.01f; 283 const int maxNumFailurePrints = 5; 284 int numFailuresDetected = 0; 285 286 for (int subNdx = 0; subNdx < static_cast<int>(subset.size()); ++subNdx) 287 { 288 const tcu::Vec3& subPt = subset[subNdx]; 289 290 bool matchFound = false; 291 292 { 293 // Binary search the index of the first point in supersetSorted with x in the [subPt.x() - epsilon, subPt.x() + epsilon] range. 294 const tcu::Vec3 matchMin = subPt - epsilon; 295 const tcu::Vec3 matchMax = subPt + epsilon; 296 const int firstCandidateNdx = binarySearchFirstVec3WithXAtLeast(supersetSorted, matchMin.x()); 297 298 if (firstCandidateNdx >= 0) 299 { 300 // Compare subPt to all points in supersetSorted with x in the [subPt.x() - epsilon, subPt.x() + epsilon] range. 301 for (int superNdx = firstCandidateNdx; superNdx < static_cast<int>(supersetSorted.size()) && supersetSorted[superNdx].x() <= matchMax.x(); ++superNdx) 302 { 303 const tcu::Vec3& superPt = supersetSorted[superNdx]; 304 305 if (tcu::boolAll(tcu::greaterThanEqual (superPt, matchMin)) && 306 tcu::boolAll(tcu::lessThanEqual (superPt, matchMax))) 307 { 308 matchFound = true; 309 break; 310 } 311 } 312 } 313 } 314 315 if (!matchFound) 316 { 317 ++numFailuresDetected; 318 if (numFailuresDetected < maxNumFailurePrints) 319 log << tcu::TestLog::Message << "Failure: no matching " << supersetName << " point found for " << subsetName << " point " << subPt << tcu::TestLog::EndMessage; 320 else if (numFailuresDetected == maxNumFailurePrints) 321 log << tcu::TestLog::Message << "Note: More errors follow" << tcu::TestLog::EndMessage; 322 323 drawTessCoordPoint(errorDst, primitiveType, subPt, errorColor, 4); 324 } 325 } 326 327 return numFailuresDetected == 0; 328 } 329 330 //! Returns true on matching coordinate sets. 331 bool compareTessCoords (tcu::TestLog& log, 332 TessPrimitiveType primitiveType, 333 const std::vector<tcu::Vec3>& refCoords, 334 const std::vector<tcu::Vec3>& resCoords) 335 { 336 tcu::Surface refVisual; 337 tcu::Surface resVisual; 338 bool success = true; 339 340 drawTessCoordVisualization(refVisual, primitiveType, refCoords); 341 drawTessCoordVisualization(resVisual, primitiveType, resCoords); 342 343 // Check that all points in reference also exist in result. 344 success = oneWayComparePointSets(log, refVisual, primitiveType, refCoords, resCoords, "reference", "result", tcu::RGBA::blue()) && success; 345 // Check that all points in result also exist in reference. 346 success = oneWayComparePointSets(log, resVisual, primitiveType, resCoords, refCoords, "result", "reference", tcu::RGBA::red()) && success; 347 348 if (!success) 349 { 350 log << tcu::TestLog::Message << "Note: in the following reference visualization, points that are missing in result point set are blue (if any)" << tcu::TestLog::EndMessage 351 << tcu::TestLog::Image("RefTessCoordVisualization", "Reference tessCoord visualization", refVisual) 352 << tcu::TestLog::Message << "Note: in the following result visualization, points that are missing in reference point set are red (if any)" << tcu::TestLog::EndMessage; 353 } 354 355 log << tcu::TestLog::Image("ResTessCoordVisualization", "Result tessCoord visualization", resVisual); 356 357 return success; 358 } 359 360 class TessCoordTest : public TestCase 361 { 362 public: 363 TessCoordTest (tcu::TestContext& testCtx, 364 const TessPrimitiveType primitiveType, 365 const SpacingMode spacingMode); 366 367 void initPrograms (SourceCollections& programCollection) const; 368 TestInstance* createInstance (Context& context) const; 369 370 private: 371 const TessPrimitiveType m_primitiveType; 372 const SpacingMode m_spacingMode; 373 }; 374 375 TessCoordTest::TessCoordTest (tcu::TestContext& testCtx, 376 const TessPrimitiveType primitiveType, 377 const SpacingMode spacingMode) 378 : TestCase (testCtx, getCaseName(primitiveType, spacingMode), "") 379 , m_primitiveType (primitiveType) 380 , m_spacingMode (spacingMode) 381 { 382 } 383 384 void TessCoordTest::initPrograms (SourceCollections& programCollection) const 385 { 386 // Vertex shader - no inputs 387 { 388 std::ostringstream src; 389 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 390 << "\n" 391 << "void main (void)\n" 392 << "{\n" 393 << "}\n"; 394 395 programCollection.glslSources.add("vert") << glu::VertexSource(src.str()); 396 } 397 398 // Tessellation control shader 399 { 400 std::ostringstream src; 401 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 402 << "#extension GL_EXT_tessellation_shader : require\n" 403 << "\n" 404 << "layout(vertices = 1) out;\n" 405 << "\n" 406 << "layout(set = 0, binding = 0, std430) readonly restrict buffer TessLevels {\n" 407 << " float inner0;\n" 408 << " float inner1;\n" 409 << " float outer0;\n" 410 << " float outer1;\n" 411 << " float outer2;\n" 412 << " float outer3;\n" 413 << "} sb_levels;\n" 414 << "\n" 415 << "void main (void)\n" 416 << "{\n" 417 << " gl_TessLevelInner[0] = sb_levels.inner0;\n" 418 << " gl_TessLevelInner[1] = sb_levels.inner1;\n" 419 << "\n" 420 << " gl_TessLevelOuter[0] = sb_levels.outer0;\n" 421 << " gl_TessLevelOuter[1] = sb_levels.outer1;\n" 422 << " gl_TessLevelOuter[2] = sb_levels.outer2;\n" 423 << " gl_TessLevelOuter[3] = sb_levels.outer3;\n" 424 << "}\n"; 425 426 programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()); 427 } 428 429 // Tessellation evaluation shader 430 { 431 std::ostringstream src; 432 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 433 << "#extension GL_EXT_tessellation_shader : require\n" 434 << "\n" 435 << "layout(" << getTessPrimitiveTypeShaderName(m_primitiveType) << ", " 436 << getSpacingModeShaderName(m_spacingMode) << ", point_mode) in;\n" 437 << "\n" 438 << "layout(set = 0, binding = 1, std430) coherent restrict buffer Output {\n" 439 << " int numInvocations;\n" 440 << " vec3 tessCoord[];\n" // alignment is 16 bytes, same as vec4 441 << "} sb_out;\n" 442 << "\n" 443 << "void main (void)\n" 444 << "{\n" 445 << " int index = atomicAdd(sb_out.numInvocations, 1);\n" 446 << " sb_out.tessCoord[index] = gl_TessCoord;\n" 447 << "}\n"; 448 449 programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()); 450 } 451 } 452 453 class TessCoordTestInstance : public TestInstance 454 { 455 public: 456 TessCoordTestInstance (Context& context, 457 const TessPrimitiveType primitiveType, 458 const SpacingMode spacingMode); 459 460 tcu::TestStatus iterate (void); 461 462 private: 463 const TessPrimitiveType m_primitiveType; 464 const SpacingMode m_spacingMode; 465 }; 466 467 TessCoordTestInstance::TessCoordTestInstance (Context& context, 468 const TessPrimitiveType primitiveType, 469 const SpacingMode spacingMode) 470 : TestInstance (context) 471 , m_primitiveType (primitiveType) 472 , m_spacingMode (spacingMode) 473 { 474 } 475 476 tcu::TestStatus TessCoordTestInstance::iterate (void) 477 { 478 const DeviceInterface& vk = m_context.getDeviceInterface(); 479 const VkDevice device = m_context.getDevice(); 480 const VkQueue queue = m_context.getUniversalQueue(); 481 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); 482 Allocator& allocator = m_context.getDefaultAllocator(); 483 484 // Test data 485 486 const std::vector<TessLevels> tessLevelCases = genTessLevelCases(m_primitiveType, m_spacingMode); 487 std::vector<std::vector<tcu::Vec3> > allReferenceTessCoords (tessLevelCases.size()); 488 489 for (deUint32 i = 0; i < tessLevelCases.size(); ++i) 490 allReferenceTessCoords[i] = generateReferenceTessCoords(m_primitiveType, m_spacingMode, &tessLevelCases[i].inner[0], &tessLevelCases[i].outer[0]); 491 492 const size_t maxNumVertices = static_cast<int>(std::max_element(allReferenceTessCoords.begin(), allReferenceTessCoords.end(), SizeLessThan<std::vector<tcu::Vec3> >())->size()); 493 494 // Input buffer: tessellation levels. Data is filled in later. 495 496 const Buffer tessLevelsBuffer(vk, device, allocator, 497 makeBufferCreateInfo(sizeof(TessLevels), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible); 498 499 // Output buffer: number of invocations + padding + tessellation coordinates. Initialized later. 500 501 const int resultBufferTessCoordsOffset = 4 * (int)sizeof(deInt32); 502 const int extraneousVertices = 16; // allow some room for extraneous vertices from duplicate shader invocations (number is arbitrary) 503 const VkDeviceSize resultBufferSizeBytes = resultBufferTessCoordsOffset + (maxNumVertices + extraneousVertices)*sizeof(tcu::Vec4); 504 const Buffer resultBuffer (vk, device, allocator, makeBufferCreateInfo(resultBufferSizeBytes, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible); 505 506 // Descriptors 507 508 const Unique<VkDescriptorSetLayout> descriptorSetLayout(DescriptorSetLayoutBuilder() 509 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) 510 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) 511 .build(vk, device)); 512 513 const Unique<VkDescriptorPool> descriptorPool(DescriptorPoolBuilder() 514 .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) 515 .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) 516 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u)); 517 518 const Unique<VkDescriptorSet> descriptorSet(makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout)); 519 520 const VkDescriptorBufferInfo tessLevelsBufferInfo = makeDescriptorBufferInfo(tessLevelsBuffer.get(), 0ull, sizeof(TessLevels)); 521 const VkDescriptorBufferInfo resultBufferInfo = makeDescriptorBufferInfo(resultBuffer.get(), 0ull, resultBufferSizeBytes); 522 523 DescriptorSetUpdateBuilder() 524 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &tessLevelsBufferInfo) 525 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultBufferInfo) 526 .update(vk, device); 527 528 // Pipeline: set up vertex processing without rasterization 529 530 const Unique<VkRenderPass> renderPass (makeRenderPassWithoutAttachments (vk, device)); 531 const Unique<VkFramebuffer> framebuffer (makeFramebufferWithoutAttachments(vk, device, *renderPass)); 532 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout)); 533 const Unique<VkCommandPool> cmdPool (makeCommandPool(vk, device, queueFamilyIndex)); 534 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 535 536 const Unique<VkPipeline> pipeline(GraphicsPipelineBuilder() 537 .setShader(vk, device, VK_SHADER_STAGE_VERTEX_BIT, m_context.getBinaryCollection().get("vert"), DE_NULL) 538 .setShader(vk, device, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, m_context.getBinaryCollection().get("tesc"), DE_NULL) 539 .setShader(vk, device, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, m_context.getBinaryCollection().get("tese"), DE_NULL) 540 .build (vk, device, *pipelineLayout, *renderPass)); 541 542 deUint32 numPassedCases = 0; 543 544 // Repeat the test for all tessellation coords cases 545 for (deUint32 tessLevelCaseNdx = 0; tessLevelCaseNdx < tessLevelCases.size(); ++tessLevelCaseNdx) 546 { 547 m_context.getTestContext().getLog() 548 << tcu::TestLog::Message 549 << "Tessellation levels: " << getTessellationLevelsString(tessLevelCases[tessLevelCaseNdx], m_primitiveType) 550 << tcu::TestLog::EndMessage; 551 552 // Upload tessellation levels data to the input buffer 553 { 554 const Allocation& alloc = tessLevelsBuffer.getAllocation(); 555 TessLevels* const bufferTessLevels = static_cast<TessLevels*>(alloc.getHostPtr()); 556 *bufferTessLevels = tessLevelCases[tessLevelCaseNdx]; 557 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), sizeof(TessLevels)); 558 } 559 560 // Clear the results buffer 561 { 562 const Allocation& alloc = resultBuffer.getAllocation(); 563 deMemset(alloc.getHostPtr(), 0, static_cast<std::size_t>(resultBufferSizeBytes)); 564 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), resultBufferSizeBytes); 565 } 566 567 // Reset the command buffer and begin recording. 568 beginCommandBuffer(vk, *cmdBuffer); 569 beginRenderPassWithRasterizationDisabled(vk, *cmdBuffer, *renderPass, *framebuffer); 570 571 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline); 572 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL); 573 574 // Process a single abstract vertex. 575 vk.cmdDraw(*cmdBuffer, 1u, 1u, 0u, 0u); 576 endRenderPass(vk, *cmdBuffer); 577 578 { 579 const VkBufferMemoryBarrier shaderWriteBarrier = makeBufferMemoryBarrier( 580 VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *resultBuffer, 0ull, resultBufferSizeBytes); 581 582 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 583 0u, DE_NULL, 1u, &shaderWriteBarrier, 0u, DE_NULL); 584 } 585 586 endCommandBuffer(vk, *cmdBuffer); 587 submitCommandsAndWait(vk, device, queue, *cmdBuffer); 588 589 // Verify results 590 { 591 const Allocation& resultAlloc = resultBuffer.getAllocation(); 592 invalidateMappedMemoryRange(vk, device, resultAlloc.getMemory(), resultAlloc.getOffset(), resultBufferSizeBytes); 593 594 const deInt32 numResults = *static_cast<deInt32*>(resultAlloc.getHostPtr()); 595 const std::vector<tcu::Vec3> resultTessCoords = readInterleavedData<tcu::Vec3>(numResults, resultAlloc.getHostPtr(), resultBufferTessCoordsOffset, sizeof(tcu::Vec4)); 596 const std::vector<tcu::Vec3>& referenceTessCoords = allReferenceTessCoords[tessLevelCaseNdx]; 597 const int numExpectedResults = static_cast<int>(referenceTessCoords.size()); 598 tcu::TestLog& log = m_context.getTestContext().getLog(); 599 600 if (numResults < numExpectedResults) 601 { 602 log << tcu::TestLog::Message 603 << "Failure: generated " << numResults << " coordinates, but the expected reference value is " << numExpectedResults 604 << tcu::TestLog::EndMessage; 605 } 606 else if (numResults == numExpectedResults) 607 log << tcu::TestLog::Message << "Note: generated " << numResults << " tessellation coordinates" << tcu::TestLog::EndMessage; 608 else 609 { 610 log << tcu::TestLog::Message 611 << "Note: generated " << numResults << " coordinates (out of which " << numExpectedResults << " must be unique)" 612 << tcu::TestLog::EndMessage; 613 } 614 615 if (m_primitiveType == TESSPRIMITIVETYPE_TRIANGLES) 616 log << tcu::TestLog::Message << "Note: in the following visualization(s), the u=1, v=1, w=1 corners are at the right, top, and left corners, respectively" << tcu::TestLog::EndMessage; 617 else if (m_primitiveType == TESSPRIMITIVETYPE_QUADS || m_primitiveType == TESSPRIMITIVETYPE_ISOLINES) 618 log << tcu::TestLog::Message << "Note: in the following visualization(s), u and v coordinate go left-to-right and bottom-to-top, respectively" << tcu::TestLog::EndMessage; 619 else 620 DE_ASSERT(false); 621 622 if (compareTessCoords(log, m_primitiveType, referenceTessCoords, resultTessCoords) && (numResults >= numExpectedResults)) 623 ++numPassedCases; 624 } 625 } // for tessLevelCaseNdx 626 627 return (numPassedCases == tessLevelCases.size() ? tcu::TestStatus::pass("OK") : tcu::TestStatus::fail("Some cases have failed")); 628 } 629 630 TestInstance* TessCoordTest::createInstance (Context& context) const 631 { 632 requireFeatures(context.getInstanceInterface(), context.getPhysicalDevice(), FEATURE_TESSELLATION_SHADER | FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS); 633 634 return new TessCoordTestInstance(context, m_primitiveType, m_spacingMode); 635 } 636 637 } // anonymous 638 639 //! Based on dEQP-GLES31.functional.tessellation.tesscoord.* 640 //! \note Transform feedback is replaced with SSBO. Because of that, this version allows duplicate coordinates from shader invocations. 641 //! The test still fails if not enough coordinates are generated, or if coordinates don't match the reference data. 642 tcu::TestCaseGroup* createCoordinatesTests (tcu::TestContext& testCtx) 643 { 644 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "tesscoord", "Tessellation coordinates tests")); 645 646 for (int primitiveTypeNdx = 0; primitiveTypeNdx < TESSPRIMITIVETYPE_LAST; ++primitiveTypeNdx) 647 for (int spacingModeNdx = 0; spacingModeNdx < SPACINGMODE_LAST; ++spacingModeNdx) 648 group->addChild(new TessCoordTest(testCtx, (TessPrimitiveType)primitiveTypeNdx, (SpacingMode)spacingModeNdx)); 649 650 return group.release(); 651 } 652 653 } // tessellation 654 } // vkt 655
