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 Common Edge Tests 23 *//*--------------------------------------------------------------------*/ 24 25 #include "vktTessellationCommonEdgeTests.hpp" 26 #include "vktTestCaseUtil.hpp" 27 #include "vktTessellationUtil.hpp" 28 29 #include "tcuTestLog.hpp" 30 #include "tcuTexture.hpp" 31 32 #include "vkDefs.hpp" 33 #include "vkQueryUtil.hpp" 34 #include "vkBuilderUtil.hpp" 35 #include "vkImageUtil.hpp" 36 #include "vkTypeUtil.hpp" 37 #include "vkStrUtil.hpp" 38 39 #include "deUniquePtr.hpp" 40 #include "deStringUtil.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 enum CaseType 56 { 57 CASETYPE_BASIC = 0, //!< Order patch vertices such that when two patches share a vertex, it's at the same index for both. 58 CASETYPE_PRECISE, //!< Vertex indices don't match like for CASETYPE_BASIC, but other measures are taken, using the 'precise' qualifier. 59 60 CASETYPE_LAST 61 }; 62 63 struct CaseDefinition 64 { 65 TessPrimitiveType primitiveType; 66 SpacingMode spacingMode; 67 CaseType caseType; 68 }; 69 70 //! Check that a certain rectangle in the image contains no black pixels. 71 //! Returns true if an image successfully passess the verification. 72 bool verifyResult (tcu::TestLog& log, const tcu::ConstPixelBufferAccess image) 73 { 74 const int startX = static_cast<int>(0.15f * (float)image.getWidth()); 75 const int endX = static_cast<int>(0.85f * (float)image.getWidth()); 76 const int startY = static_cast<int>(0.15f * (float)image.getHeight()); 77 const int endY = static_cast<int>(0.85f * (float)image.getHeight()); 78 79 for (int y = startY; y < endY; ++y) 80 for (int x = startX; x < endX; ++x) 81 { 82 const tcu::Vec4 pixel = image.getPixel(x, y); 83 84 if (pixel.x() == 0 && pixel.y() == 0 && pixel.z() == 0) 85 { 86 log << tcu::TestLog::Message << "Failure: there seem to be cracks in the rendered result" << tcu::TestLog::EndMessage 87 << tcu::TestLog::Message << "Note: pixel with zero r, g and b channels found at " << tcu::IVec2(x, y) << tcu::TestLog::EndMessage; 88 89 return false; 90 } 91 } 92 93 log << tcu::TestLog::Message << "Success: there seem to be no cracks in the rendered result" << tcu::TestLog::EndMessage; 94 95 return true; 96 } 97 98 void initPrograms (vk::SourceCollections& programCollection, const CaseDefinition caseDef) 99 { 100 DE_ASSERT(caseDef.primitiveType == TESSPRIMITIVETYPE_TRIANGLES || caseDef.primitiveType == TESSPRIMITIVETYPE_QUADS); 101 102 // Vertex shader 103 { 104 std::ostringstream src; 105 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 106 << "\n" 107 << "layout(location = 0) in highp vec2 in_v_position;\n" 108 << "layout(location = 1) in highp float in_v_tessParam;\n" 109 << "\n" 110 << "layout(location = 0) out highp vec2 in_tc_position;\n" 111 << "layout(location = 1) out highp float in_tc_tessParam;\n" 112 << "\n" 113 << "void main (void)\n" 114 << "{\n" 115 << " in_tc_position = in_v_position;\n" 116 << " in_tc_tessParam = in_v_tessParam;\n" 117 << "}\n"; 118 119 programCollection.glslSources.add("vert") << glu::VertexSource(src.str()); 120 } 121 122 // Tessellation control shader 123 { 124 const int numVertices = (caseDef.primitiveType == TESSPRIMITIVETYPE_TRIANGLES ? 3 : 4); 125 126 std::ostringstream src; 127 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 128 << "#extension GL_EXT_tessellation_shader : require\n" 129 << (caseDef.caseType == CASETYPE_PRECISE ? "#extension GL_EXT_gpu_shader5 : require\n" : "") 130 << "\n" 131 << "layout(vertices = " << numVertices << ") out;\n" 132 << "\n" 133 << "layout(location = 0) in highp vec2 in_tc_position[];\n" 134 << "layout(location = 1) in highp float in_tc_tessParam[];\n" 135 << "\n" 136 << "layout(location = 0) out highp vec2 in_te_position[];\n" 137 << "\n" 138 << (caseDef.caseType == CASETYPE_PRECISE ? "precise gl_TessLevelOuter;\n\n" : "") 139 << "void main (void)\n" 140 << "{\n" 141 << " in_te_position[gl_InvocationID] = in_tc_position[gl_InvocationID];\n" 142 << "\n" 143 << " gl_TessLevelInner[0] = 5.0;\n" 144 << " gl_TessLevelInner[1] = 5.0;\n" 145 << "\n" 146 << (caseDef.primitiveType == TESSPRIMITIVETYPE_TRIANGLES ? 147 " gl_TessLevelOuter[0] = 1.0 + 59.0 * 0.5 * (in_tc_tessParam[1] + in_tc_tessParam[2]);\n" 148 " gl_TessLevelOuter[1] = 1.0 + 59.0 * 0.5 * (in_tc_tessParam[2] + in_tc_tessParam[0]);\n" 149 " gl_TessLevelOuter[2] = 1.0 + 59.0 * 0.5 * (in_tc_tessParam[0] + in_tc_tessParam[1]);\n" 150 : caseDef.primitiveType == TESSPRIMITIVETYPE_QUADS ? 151 " gl_TessLevelOuter[0] = 1.0 + 59.0 * 0.5 * (in_tc_tessParam[0] + in_tc_tessParam[2]);\n" 152 " gl_TessLevelOuter[1] = 1.0 + 59.0 * 0.5 * (in_tc_tessParam[1] + in_tc_tessParam[0]);\n" 153 " gl_TessLevelOuter[2] = 1.0 + 59.0 * 0.5 * (in_tc_tessParam[3] + in_tc_tessParam[1]);\n" 154 " gl_TessLevelOuter[3] = 1.0 + 59.0 * 0.5 * (in_tc_tessParam[2] + in_tc_tessParam[3]);\n" 155 : "") 156 << "}\n"; 157 158 programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()); 159 } 160 161 // Tessellation evaluation shader 162 { 163 std::ostringstream primitiveSpecificCode; 164 if (caseDef.primitiveType == TESSPRIMITIVETYPE_TRIANGLES) 165 primitiveSpecificCode 166 << " highp vec2 pos = gl_TessCoord.x*in_te_position[0] + gl_TessCoord.y*in_te_position[1] + gl_TessCoord.z*in_te_position[2];\n" 167 << "\n" 168 << " highp float f = sqrt(3.0 * min(gl_TessCoord.x, min(gl_TessCoord.y, gl_TessCoord.z))) * 0.5 + 0.5;\n" 169 << " in_f_color = vec4(gl_TessCoord*f, 1.0);\n"; 170 else if (caseDef.primitiveType == TESSPRIMITIVETYPE_QUADS) 171 primitiveSpecificCode 172 << (caseDef.caseType == CASETYPE_BASIC ? 173 " highp vec2 pos = (1.0-gl_TessCoord.x)*(1.0-gl_TessCoord.y)*in_te_position[0]\n" 174 " + ( gl_TessCoord.x)*(1.0-gl_TessCoord.y)*in_te_position[1]\n" 175 " + (1.0-gl_TessCoord.x)*( gl_TessCoord.y)*in_te_position[2]\n" 176 " + ( gl_TessCoord.x)*( gl_TessCoord.y)*in_te_position[3];\n" 177 : caseDef.caseType == CASETYPE_PRECISE ? 178 " highp vec2 a = (1.0-gl_TessCoord.x)*(1.0-gl_TessCoord.y)*in_te_position[0];\n" 179 " highp vec2 b = ( gl_TessCoord.x)*(1.0-gl_TessCoord.y)*in_te_position[1];\n" 180 " highp vec2 c = (1.0-gl_TessCoord.x)*( gl_TessCoord.y)*in_te_position[2];\n" 181 " highp vec2 d = ( gl_TessCoord.x)*( gl_TessCoord.y)*in_te_position[3];\n" 182 " highp vec2 pos = a+b+c+d;\n" 183 : "") 184 << "\n" 185 << " highp float f = sqrt(1.0 - 2.0 * max(abs(gl_TessCoord.x - 0.5), abs(gl_TessCoord.y - 0.5)))*0.5 + 0.5;\n" 186 << " in_f_color = vec4(0.1, gl_TessCoord.xy*f, 1.0);\n"; 187 188 std::ostringstream src; 189 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 190 << "#extension GL_EXT_tessellation_shader : require\n" 191 << (caseDef.caseType == CASETYPE_PRECISE ? "#extension GL_EXT_gpu_shader5 : require\n" : "") 192 << "\n" 193 << "layout(" << getTessPrimitiveTypeShaderName(caseDef.primitiveType) << ", " 194 << getSpacingModeShaderName(caseDef.spacingMode) << ") in;\n" 195 << "\n" 196 << "layout(location = 0) in highp vec2 in_te_position[];\n" 197 << "\n" 198 << "layout(location = 0) out mediump vec4 in_f_color;\n" 199 << "\n" 200 << (caseDef.caseType == CASETYPE_PRECISE ? "precise gl_Position;\n\n" : "") 201 << "void main (void)\n" 202 << "{\n" 203 << primitiveSpecificCode.str() 204 << "\n" 205 << " // Offset the position slightly, based on the parity of the bits in the float representation.\n" 206 << " // This is done to detect possible small differences in edge vertex positions between patches.\n" 207 << " uvec2 bits = floatBitsToUint(pos);\n" 208 << " uint numBits = 0u;\n" 209 << " for (uint i = 0u; i < 32u; i++)\n" 210 << " numBits += ((bits[0] >> i) & 1u) + ((bits[1] >> i) & 1u);\n" 211 << " pos += float(numBits&1u)*0.04;\n" 212 << "\n" 213 << " gl_Position = vec4(pos, 0.0, 1.0);\n" 214 << "}\n"; 215 216 programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()); 217 } 218 219 // Fragment shader 220 { 221 std::ostringstream src; 222 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 223 << "\n" 224 << "layout(location = 0) in mediump vec4 in_f_color;\n" 225 << "\n" 226 << "layout(location = 0) out mediump vec4 o_color;\n" 227 << "\n" 228 << "void main (void)\n" 229 << "{\n" 230 << " o_color = in_f_color;\n" 231 << "}\n"; 232 233 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()); 234 } 235 } 236 237 //! Generic test code used by all test cases. 238 tcu::TestStatus test (Context& context, const CaseDefinition caseDef) 239 { 240 DE_ASSERT(caseDef.primitiveType == TESSPRIMITIVETYPE_TRIANGLES || caseDef.primitiveType == TESSPRIMITIVETYPE_QUADS); 241 DE_ASSERT(caseDef.caseType == CASETYPE_BASIC || caseDef.caseType == CASETYPE_PRECISE); 242 243 requireFeatures(context.getInstanceInterface(), context.getPhysicalDevice(), FEATURE_TESSELLATION_SHADER); 244 245 const DeviceInterface& vk = context.getDeviceInterface(); 246 const VkDevice device = context.getDevice(); 247 const VkQueue queue = context.getUniversalQueue(); 248 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); 249 Allocator& allocator = context.getDefaultAllocator(); 250 251 // Prepare test data 252 253 std::vector<float> gridPosComps; 254 std::vector<float> gridTessParams; 255 std::vector<deUint16> gridIndices; 256 257 { 258 const int gridWidth = 4; 259 const int gridHeight = 4; 260 const int numVertices = (gridWidth+1)*(gridHeight+1); 261 const int numIndices = gridWidth*gridHeight * (caseDef.primitiveType == TESSPRIMITIVETYPE_TRIANGLES ? 3*2 : 4); 262 const int numPosCompsPerVertex = 2; 263 const int totalNumPosComps = numPosCompsPerVertex*numVertices; 264 265 gridPosComps.reserve(totalNumPosComps); 266 gridTessParams.reserve(numVertices); 267 gridIndices.reserve(numIndices); 268 269 { 270 for (int i = 0; i < gridHeight+1; ++i) 271 for (int j = 0; j < gridWidth+1; ++j) 272 { 273 gridPosComps.push_back(-1.0f + 2.0f * ((float)j + 0.5f) / (float)(gridWidth+1)); 274 gridPosComps.push_back(-1.0f + 2.0f * ((float)i + 0.5f) / (float)(gridHeight+1)); 275 gridTessParams.push_back((float)(i*(gridWidth+1) + j) / (float)(numVertices-1)); 276 } 277 } 278 279 // Generate patch vertex indices. 280 // \note If CASETYPE_BASIC, the vertices are ordered such that when multiple 281 // triangles/quads share a vertex, it's at the same index for everyone. 282 283 if (caseDef.primitiveType == TESSPRIMITIVETYPE_TRIANGLES) 284 { 285 for (int i = 0; i < gridHeight; i++) 286 for (int j = 0; j < gridWidth; j++) 287 { 288 const deUint16 corners[4] = 289 { 290 (deUint16)((i+0)*(gridWidth+1) + j+0), 291 (deUint16)((i+0)*(gridWidth+1) + j+1), 292 (deUint16)((i+1)*(gridWidth+1) + j+0), 293 (deUint16)((i+1)*(gridWidth+1) + j+1) 294 }; 295 296 const int secondTriangleVertexIndexOffset = caseDef.caseType == CASETYPE_BASIC ? 0 : 1; 297 298 for (int k = 0; k < 3; k++) 299 gridIndices.push_back(corners[(k+0 + i + (2-j%3)) % 3]); 300 for (int k = 0; k < 3; k++) 301 gridIndices.push_back(corners[(k+2 + i + (2-j%3) + secondTriangleVertexIndexOffset) % 3 + 1]); 302 } 303 } 304 else if (caseDef.primitiveType == TESSPRIMITIVETYPE_QUADS) 305 { 306 for (int i = 0; i < gridHeight; ++i) 307 for (int j = 0; j < gridWidth; ++j) 308 { 309 for (int m = 0; m < 2; m++) 310 for (int n = 0; n < 2; n++) 311 gridIndices.push_back((deUint16)((i+(i+m)%2)*(gridWidth+1) + j+(j+n)%2)); 312 313 if (caseDef.caseType == CASETYPE_PRECISE && (i+j) % 2 == 0) 314 std::reverse(gridIndices.begin() + (gridIndices.size() - 4), 315 gridIndices.begin() + gridIndices.size()); 316 } 317 } 318 else 319 DE_ASSERT(false); 320 321 DE_ASSERT(static_cast<int>(gridPosComps.size()) == totalNumPosComps); 322 DE_ASSERT(static_cast<int>(gridTessParams.size()) == numVertices); 323 DE_ASSERT(static_cast<int>(gridIndices.size()) == numIndices); 324 } 325 326 // Vertex input buffer: we put both attributes and indices in here. 327 328 const VkDeviceSize vertexDataSizeBytes = sizeInBytes(gridPosComps) + sizeInBytes(gridTessParams) + sizeInBytes(gridIndices); 329 const std::size_t vertexPositionsOffset = 0; 330 const std::size_t vertexTessParamsOffset = sizeInBytes(gridPosComps); 331 const std::size_t vertexIndicesOffset = vertexTessParamsOffset + sizeInBytes(gridTessParams); 332 333 const Buffer vertexBuffer(vk, device, allocator, 334 makeBufferCreateInfo(vertexDataSizeBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT), MemoryRequirement::HostVisible); 335 336 { 337 const Allocation& alloc = vertexBuffer.getAllocation(); 338 deUint8* const pData = static_cast<deUint8*>(alloc.getHostPtr()); 339 340 deMemcpy(pData + vertexPositionsOffset, &gridPosComps[0], static_cast<std::size_t>(sizeInBytes(gridPosComps))); 341 deMemcpy(pData + vertexTessParamsOffset, &gridTessParams[0], static_cast<std::size_t>(sizeInBytes(gridTessParams))); 342 deMemcpy(pData + vertexIndicesOffset, &gridIndices[0], static_cast<std::size_t>(sizeInBytes(gridIndices))); 343 344 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), vertexDataSizeBytes); 345 // No barrier needed, flushed memory is automatically visible 346 } 347 348 // Color attachment 349 350 const tcu::IVec2 renderSize = tcu::IVec2(256, 256); 351 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM; 352 const VkImageSubresourceRange colorImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u); 353 const Image colorAttachmentImage (vk, device, allocator, 354 makeImageCreateInfo(renderSize, colorFormat, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 1u), 355 MemoryRequirement::Any); 356 357 // Color output buffer: image will be copied here for verification 358 359 const VkDeviceSize colorBufferSizeBytes = renderSize.x()*renderSize.y() * tcu::getPixelSize(mapVkFormat(colorFormat)); 360 const Buffer colorBuffer (vk, device, allocator, makeBufferCreateInfo(colorBufferSizeBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible); 361 362 // Pipeline 363 364 const Unique<VkImageView> colorAttachmentView (makeImageView (vk, device, *colorAttachmentImage, VK_IMAGE_VIEW_TYPE_2D, colorFormat, colorImageSubresourceRange)); 365 const Unique<VkRenderPass> renderPass (makeRenderPass (vk, device, colorFormat)); 366 const Unique<VkFramebuffer> framebuffer (makeFramebuffer (vk, device, *renderPass, *colorAttachmentView, renderSize.x(), renderSize.y(), 1u)); 367 const Unique<VkCommandPool> cmdPool (makeCommandPool (vk, device, queueFamilyIndex)); 368 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer (vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 369 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayoutWithoutDescriptors(vk, device)); 370 371 const int inPatchSize = (caseDef.primitiveType == TESSPRIMITIVETYPE_TRIANGLES ? 3 : 4); 372 const Unique<VkPipeline> pipeline(GraphicsPipelineBuilder() 373 .setRenderSize (renderSize) 374 .setPatchControlPoints(inPatchSize) 375 .addVertexBinding (makeVertexInputBindingDescription(0u, sizeof(tcu::Vec2), VK_VERTEX_INPUT_RATE_VERTEX)) 376 .addVertexBinding (makeVertexInputBindingDescription(1u, sizeof(float), VK_VERTEX_INPUT_RATE_VERTEX)) 377 .addVertexAttribute (makeVertexInputAttributeDescription(0u, 0u, VK_FORMAT_R32G32_SFLOAT, 0u)) 378 .addVertexAttribute (makeVertexInputAttributeDescription(1u, 1u, VK_FORMAT_R32_SFLOAT, 0u)) 379 .setShader (vk, device, VK_SHADER_STAGE_VERTEX_BIT, context.getBinaryCollection().get("vert"), DE_NULL) 380 .setShader (vk, device, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, context.getBinaryCollection().get("tesc"), DE_NULL) 381 .setShader (vk, device, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, context.getBinaryCollection().get("tese"), DE_NULL) 382 .setShader (vk, device, VK_SHADER_STAGE_FRAGMENT_BIT, context.getBinaryCollection().get("frag"), DE_NULL) 383 .build (vk, device, *pipelineLayout, *renderPass)); 384 385 // Draw commands 386 387 beginCommandBuffer(vk, *cmdBuffer); 388 389 // Change color attachment image layout 390 { 391 const VkImageMemoryBarrier colorAttachmentLayoutBarrier = makeImageMemoryBarrier( 392 (VkAccessFlags)0, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 393 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 394 *colorAttachmentImage, colorImageSubresourceRange); 395 396 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0u, 397 0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentLayoutBarrier); 398 } 399 400 // Begin render pass 401 { 402 const VkRect2D renderArea = { 403 makeOffset2D(0, 0), 404 makeExtent2D(renderSize.x(), renderSize.y()), 405 }; 406 const tcu::Vec4 clearColor(0.0f, 0.0f, 0.0f, 1.0f); 407 408 beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderArea, clearColor); 409 } 410 411 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline); 412 { 413 const VkBuffer buffers[] = { *vertexBuffer, *vertexBuffer }; 414 const VkDeviceSize offsets[] = { vertexPositionsOffset, vertexTessParamsOffset, }; 415 vk.cmdBindVertexBuffers(*cmdBuffer, 0u, DE_LENGTH_OF_ARRAY(buffers), buffers, offsets); 416 417 vk.cmdBindIndexBuffer(*cmdBuffer, *vertexBuffer, vertexIndicesOffset, VK_INDEX_TYPE_UINT16); 418 } 419 420 vk.cmdDrawIndexed(*cmdBuffer, static_cast<deUint32>(gridIndices.size()), 1u, 0u, 0, 0u); 421 endRenderPass(vk, *cmdBuffer); 422 423 // Copy render result to a host-visible buffer 424 { 425 const VkImageMemoryBarrier colorAttachmentPreCopyBarrier = makeImageMemoryBarrier( 426 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, 427 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 428 *colorAttachmentImage, colorImageSubresourceRange); 429 430 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 431 0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentPreCopyBarrier); 432 } 433 { 434 const VkBufferImageCopy copyRegion = makeBufferImageCopy(makeExtent3D(renderSize.x(), renderSize.y(), 1), makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u)); 435 vk.cmdCopyImageToBuffer(*cmdBuffer, *colorAttachmentImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *colorBuffer, 1u, ©Region); 436 } 437 { 438 const VkBufferMemoryBarrier postCopyBarrier = makeBufferMemoryBarrier( 439 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *colorBuffer, 0ull, colorBufferSizeBytes); 440 441 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 442 0u, DE_NULL, 1u, &postCopyBarrier, 0u, DE_NULL); 443 } 444 445 endCommandBuffer(vk, *cmdBuffer); 446 submitCommandsAndWait(vk, device, queue, *cmdBuffer); 447 448 { 449 // Log the result image. 450 451 const Allocation& colorBufferAlloc = colorBuffer.getAllocation(); 452 invalidateMappedMemoryRange(vk, device, colorBufferAlloc.getMemory(), colorBufferAlloc.getOffset(), colorBufferSizeBytes); 453 const tcu::ConstPixelBufferAccess imagePixelAccess(mapVkFormat(colorFormat), renderSize.x(), renderSize.y(), 1, colorBufferAlloc.getHostPtr()); 454 455 tcu::TestLog& log = context.getTestContext().getLog(); 456 log << tcu::TestLog::Image("color0", "Rendered image", imagePixelAccess) 457 << tcu::TestLog::Message 458 << "Note: coloring is done to clarify the positioning and orientation of the " 459 << (caseDef.primitiveType == TESSPRIMITIVETYPE_TRIANGLES ? "triangles" : 460 caseDef.primitiveType == TESSPRIMITIVETYPE_QUADS ? "quads" : "") 461 << "; the color of a vertex corresponds to the index of that vertex in the patch" 462 << tcu::TestLog::EndMessage; 463 464 if (caseDef.caseType == CASETYPE_BASIC) 465 log << tcu::TestLog::Message << "Note: each shared vertex has the same index among the primitives it belongs to" << tcu::TestLog::EndMessage; 466 else if (caseDef.caseType == CASETYPE_PRECISE) 467 log << tcu::TestLog::Message << "Note: the 'precise' qualifier is used to avoid cracks between primitives" << tcu::TestLog::EndMessage; 468 else 469 DE_ASSERT(false); 470 471 // Verify the result. 472 473 const bool ok = verifyResult(log, imagePixelAccess); 474 return (ok ? tcu::TestStatus::pass("OK") : tcu::TestStatus::fail("Failure")); 475 } 476 } 477 478 std::string getCaseName (const TessPrimitiveType primitiveType, const SpacingMode spacingMode, const CaseType caseType) 479 { 480 std::ostringstream str; 481 str << getTessPrimitiveTypeShaderName(primitiveType) << "_" << getSpacingModeShaderName(spacingMode) 482 << (caseType == CASETYPE_PRECISE ? "_precise" : ""); 483 return str.str(); 484 } 485 486 } // anonymous 487 488 //! These tests correspond to dEQP-GLES31.functional.tessellation.common_edge.* 489 tcu::TestCaseGroup* createCommonEdgeTests (tcu::TestContext& testCtx) 490 { 491 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "common_edge", "Draw multiple adjacent shapes and check that no cracks appear between them")); 492 493 static const TessPrimitiveType primitiveTypes[] = 494 { 495 TESSPRIMITIVETYPE_TRIANGLES, 496 TESSPRIMITIVETYPE_QUADS, 497 }; 498 499 for (int primitiveTypeNdx = 0; primitiveTypeNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); ++primitiveTypeNdx) 500 for (int caseTypeNdx = 0; caseTypeNdx < CASETYPE_LAST; ++caseTypeNdx) 501 for (int spacingModeNdx = 0; spacingModeNdx < SPACINGMODE_LAST; ++spacingModeNdx) 502 { 503 const TessPrimitiveType primitiveType = primitiveTypes[primitiveTypeNdx]; 504 const CaseType caseType = static_cast<CaseType>(caseTypeNdx); 505 const SpacingMode spacingMode = static_cast<SpacingMode>(spacingModeNdx); 506 const CaseDefinition caseDef = { primitiveType, spacingMode, caseType }; 507 508 addFunctionCaseWithPrograms(group.get(), getCaseName(primitiveType, spacingMode, caseType), "", initPrograms, test, caseDef); 509 } 510 511 return group.release(); 512 } 513 514 } // tessellation 515 } // vkt 516
