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 Shader Input/Output Tests 23 *//*--------------------------------------------------------------------*/ 24 25 #include "vktTessellationShaderInputOutputTests.hpp" 26 #include "vktTestCaseUtil.hpp" 27 #include "vktTessellationUtil.hpp" 28 29 #include "tcuTestLog.hpp" 30 #include "tcuImageIO.hpp" 31 #include "tcuTexture.hpp" 32 #include "tcuImageCompare.hpp" 33 34 #include "vkDefs.hpp" 35 #include "vkQueryUtil.hpp" 36 #include "vkBuilderUtil.hpp" 37 #include "vkImageUtil.hpp" 38 #include "vkTypeUtil.hpp" 39 #include "vkStrUtil.hpp" 40 41 #include "deUniquePtr.hpp" 42 #include "deStringUtil.hpp" 43 44 #include <string> 45 #include <vector> 46 47 namespace vkt 48 { 49 namespace tessellation 50 { 51 52 using namespace vk; 53 54 namespace 55 { 56 57 enum Constants 58 { 59 RENDER_SIZE = 256, 60 }; 61 62 //! Generic test code used by all test cases. 63 tcu::TestStatus runTest (Context& context, 64 const int numPrimitives, 65 const int inPatchSize, 66 const int outPatchSize, 67 const VkFormat vertexFormat, 68 const void* vertexData, 69 const VkDeviceSize vertexDataSizeBytes, 70 const tcu::ConstPixelBufferAccess& referenceImageAccess) 71 { 72 requireFeatures(context.getInstanceInterface(), context.getPhysicalDevice(), FEATURE_TESSELLATION_SHADER); 73 74 const DeviceInterface& vk = context.getDeviceInterface(); 75 const VkDevice device = context.getDevice(); 76 const VkQueue queue = context.getUniversalQueue(); 77 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); 78 Allocator& allocator = context.getDefaultAllocator(); 79 80 // Vertex input: may be just some abstract numbers 81 82 const Buffer vertexBuffer(vk, device, allocator, 83 makeBufferCreateInfo(vertexDataSizeBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible); 84 85 { 86 const Allocation& alloc = vertexBuffer.getAllocation(); 87 deMemcpy(alloc.getHostPtr(), vertexData, static_cast<std::size_t>(vertexDataSizeBytes)); 88 89 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), vertexDataSizeBytes); 90 // No barrier needed, flushed memory is automatically visible 91 } 92 93 // Color attachment 94 95 const tcu::IVec2 renderSize = tcu::IVec2(RENDER_SIZE, RENDER_SIZE); 96 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM; 97 const VkImageSubresourceRange colorImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u); 98 const Image colorAttachmentImage (vk, device, allocator, 99 makeImageCreateInfo(renderSize, colorFormat, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 1u), 100 MemoryRequirement::Any); 101 102 // Color output buffer: image will be copied here for verification 103 104 const VkDeviceSize colorBufferSizeBytes = renderSize.x()*renderSize.y() * tcu::getPixelSize(mapVkFormat(colorFormat)); 105 const Buffer colorBuffer (vk, device, allocator, makeBufferCreateInfo(colorBufferSizeBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible); 106 107 // Pipeline 108 109 const Unique<VkImageView> colorAttachmentView(makeImageView (vk, device, *colorAttachmentImage, VK_IMAGE_VIEW_TYPE_2D, colorFormat, colorImageSubresourceRange)); 110 const Unique<VkRenderPass> renderPass (makeRenderPass (vk, device, colorFormat)); 111 const Unique<VkFramebuffer> framebuffer (makeFramebuffer (vk, device, *renderPass, *colorAttachmentView, renderSize.x(), renderSize.y(), 1u)); 112 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayoutWithoutDescriptors(vk, device)); 113 const Unique<VkCommandPool> cmdPool (makeCommandPool (vk, device, queueFamilyIndex)); 114 const Unique<VkCommandBuffer> cmdBuffer (makeCommandBuffer (vk, device, *cmdPool)); 115 116 const Unique<VkPipeline> pipeline(GraphicsPipelineBuilder() 117 .setRenderSize (renderSize) 118 .setVertexInputSingleAttribute(vertexFormat, tcu::getPixelSize(mapVkFormat(vertexFormat))) 119 .setPatchControlPoints (inPatchSize) 120 .setShader (vk, device, VK_SHADER_STAGE_VERTEX_BIT, context.getBinaryCollection().get("vert"), DE_NULL) 121 .setShader (vk, device, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, context.getBinaryCollection().get("tesc"), DE_NULL) 122 .setShader (vk, device, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, context.getBinaryCollection().get("tese"), DE_NULL) 123 .setShader (vk, device, VK_SHADER_STAGE_FRAGMENT_BIT, context.getBinaryCollection().get("frag"), DE_NULL) 124 .build (vk, device, *pipelineLayout, *renderPass)); 125 126 { 127 tcu::TestLog& log = context.getTestContext().getLog(); 128 log << tcu::TestLog::Message 129 << "Note: input patch size is " << inPatchSize << ", output patch size is " << outPatchSize 130 << tcu::TestLog::EndMessage; 131 } 132 133 // Draw commands 134 135 beginCommandBuffer(vk, *cmdBuffer); 136 137 // Change color attachment image layout 138 { 139 const VkImageMemoryBarrier colorAttachmentLayoutBarrier = makeImageMemoryBarrier( 140 (VkAccessFlags)0, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 141 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 142 *colorAttachmentImage, colorImageSubresourceRange); 143 144 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0u, 145 0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentLayoutBarrier); 146 } 147 148 // Begin render pass 149 { 150 const VkRect2D renderArea = { 151 makeOffset2D(0, 0), 152 makeExtent2D(renderSize.x(), renderSize.y()), 153 }; 154 const tcu::Vec4 clearColor(0.0f, 0.0f, 0.0f, 1.0f); 155 156 beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderArea, clearColor); 157 } 158 159 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline); 160 { 161 const VkDeviceSize vertexBufferOffset = 0ull; 162 vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset); 163 } 164 165 // Process enough vertices to make a patch. 166 vk.cmdDraw(*cmdBuffer, numPrimitives * inPatchSize, 1u, 0u, 0u); 167 endRenderPass(vk, *cmdBuffer); 168 169 // Copy render result to a host-visible buffer 170 { 171 const VkImageMemoryBarrier colorAttachmentPreCopyBarrier = makeImageMemoryBarrier( 172 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, 173 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 174 *colorAttachmentImage, colorImageSubresourceRange); 175 176 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 177 0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentPreCopyBarrier); 178 } 179 { 180 const VkBufferImageCopy copyRegion = makeBufferImageCopy(makeExtent3D(renderSize.x(), renderSize.y(), 1), makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u)); 181 vk.cmdCopyImageToBuffer(*cmdBuffer, *colorAttachmentImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *colorBuffer, 1u, ©Region); 182 } 183 { 184 const VkBufferMemoryBarrier postCopyBarrier = makeBufferMemoryBarrier( 185 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *colorBuffer, 0ull, colorBufferSizeBytes); 186 187 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 188 0u, DE_NULL, 1u, &postCopyBarrier, 0u, DE_NULL); 189 } 190 191 endCommandBuffer(vk, *cmdBuffer); 192 submitCommandsAndWait(vk, device, queue, *cmdBuffer); 193 194 { 195 const Allocation& colorBufferAlloc = colorBuffer.getAllocation(); 196 invalidateMappedMemoryRange(vk, device, colorBufferAlloc.getMemory(), colorBufferAlloc.getOffset(), colorBufferSizeBytes); 197 198 // Verify case result 199 const tcu::ConstPixelBufferAccess resultImageAccess(mapVkFormat(colorFormat), renderSize.x(), renderSize.y(), 1, colorBufferAlloc.getHostPtr()); 200 tcu::TestLog& log = context.getTestContext().getLog(); 201 const bool ok = tcu::fuzzyCompare(log, "ImageComparison", "Image Comparison", referenceImageAccess, resultImageAccess, 0.002f, tcu::COMPARE_LOG_RESULT); 202 203 return (ok ? tcu::TestStatus::pass("OK") : tcu::TestStatus::fail("Failure")); 204 } 205 } 206 207 namespace PatchVertexCount 208 { 209 210 struct CaseDefinition 211 { 212 int inPatchSize; 213 int outPatchSize; 214 std::string referenceImagePath; 215 }; 216 217 void initPrograms (vk::SourceCollections& programCollection, const CaseDefinition caseDef) 218 { 219 // Vertex shader 220 { 221 std::ostringstream src; 222 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 223 << "\n" 224 << "layout(location = 0) in highp float in_v_attr;\n" 225 << "layout(location = 0) out highp float in_tc_attr;\n" 226 << "\n" 227 << "void main (void)\n" 228 << "{\n" 229 << " in_tc_attr = in_v_attr;\n" 230 << "}\n"; 231 232 programCollection.glslSources.add("vert") << glu::VertexSource(src.str()); 233 } 234 235 // Tessellation control shader 236 { 237 std::ostringstream src; 238 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 239 << "#extension GL_EXT_tessellation_shader : require\n" 240 << "\n" 241 << "layout(vertices = " << caseDef.outPatchSize << ") out;\n" 242 << "\n" 243 << "layout(location = 0) in highp float in_tc_attr[];\n" 244 << "layout(location = 0) out highp float in_te_attr[];\n" 245 << "\n" 246 << "void main (void)\n" 247 << "{\n" 248 << " in_te_attr[gl_InvocationID] = in_tc_attr[gl_InvocationID*" << caseDef.inPatchSize << "/" << caseDef.outPatchSize << "];\n" 249 << "\n" 250 << " gl_TessLevelInner[0] = 5.0;\n" 251 << " gl_TessLevelInner[1] = 5.0;\n" 252 << "\n" 253 << " gl_TessLevelOuter[0] = 5.0;\n" 254 << " gl_TessLevelOuter[1] = 5.0;\n" 255 << " gl_TessLevelOuter[2] = 5.0;\n" 256 << " gl_TessLevelOuter[3] = 5.0;\n" 257 << "}\n"; 258 259 programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()); 260 } 261 262 // Tessellation evaluation shader 263 { 264 std::ostringstream src; 265 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 266 << "#extension GL_EXT_tessellation_shader : require\n" 267 << "\n" 268 << "layout(" << getTessPrimitiveTypeShaderName(TESSPRIMITIVETYPE_QUADS) << ") in;\n" 269 << "\n" 270 << "layout(location = 0) in highp float in_te_attr[];\n" 271 << "layout(location = 0) out mediump vec4 in_f_color;\n" 272 << "\n" 273 << "void main (void)\n" 274 << "{\n" 275 << " highp float x = gl_TessCoord.x*2.0 - 1.0;\n" 276 << " highp float y = gl_TessCoord.y - in_te_attr[int(round(gl_TessCoord.x*float(" << caseDef.outPatchSize << "-1)))];\n" 277 << " gl_Position = vec4(x, y, 0.0, 1.0);\n" 278 << " in_f_color = vec4(1.0);\n" 279 << "}\n"; 280 281 programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()); 282 } 283 284 // Fragment shader 285 { 286 std::ostringstream src; 287 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 288 << "\n" 289 << "layout(location = 0) in mediump vec4 in_f_color;\n" 290 << "layout(location = 0) out mediump vec4 o_color;\n" 291 << "\n" 292 << "void main (void)\n" 293 << "{\n" 294 << " o_color = in_f_color;\n" 295 << "}\n"; 296 297 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()); 298 } 299 } 300 301 tcu::TestStatus test (Context& context, const CaseDefinition caseDef) 302 { 303 // Input vertex attribute data 304 std::vector<float> vertexData; 305 vertexData.reserve(caseDef.inPatchSize); 306 for (int i = 0; i < caseDef.inPatchSize; ++i) 307 { 308 const float f = static_cast<float>(i) / static_cast<float>(caseDef.inPatchSize - 1); 309 vertexData.push_back(f*f); 310 } 311 const VkDeviceSize vertexBufferSize = sizeof(float) * vertexData.size(); 312 313 // Load reference image 314 tcu::TextureLevel referenceImage; 315 tcu::ImageIO::loadPNG(referenceImage, context.getTestContext().getArchive(), caseDef.referenceImagePath.c_str()); 316 317 const int numPrimitives = 1; 318 319 return runTest(context, numPrimitives, caseDef.inPatchSize, caseDef.outPatchSize, 320 VK_FORMAT_R32_SFLOAT, &vertexData[0], vertexBufferSize, referenceImage.getAccess()); 321 } 322 323 } // PatchVertexCountTest ns 324 325 namespace PerPatchData 326 { 327 328 enum CaseType 329 { 330 CASETYPE_PRIMITIVE_ID_TCS, 331 CASETYPE_PRIMITIVE_ID_TES, 332 CASETYPE_PATCH_VERTICES_IN_TCS, 333 CASETYPE_PATCH_VERTICES_IN_TES, 334 CASETYPE_TESS_LEVEL_INNER0_TES, 335 CASETYPE_TESS_LEVEL_INNER1_TES, 336 CASETYPE_TESS_LEVEL_OUTER0_TES, 337 CASETYPE_TESS_LEVEL_OUTER1_TES, 338 CASETYPE_TESS_LEVEL_OUTER2_TES, 339 CASETYPE_TESS_LEVEL_OUTER3_TES, 340 }; 341 342 enum Constants 343 { 344 OUTPUT_PATCH_SIZE = 5, 345 INPUT_PATCH_SIZE = 10, 346 }; 347 348 struct CaseDefinition 349 { 350 CaseType caseType; 351 std::string caseName; 352 bool usesReferenceImageFromFile; 353 std::string referenceImagePath; 354 std::string caseDescription; 355 }; 356 357 int getNumPrimitives (const CaseType type) 358 { 359 return (type == CASETYPE_PRIMITIVE_ID_TCS || type == CASETYPE_PRIMITIVE_ID_TES ? 8 : 1); 360 } 361 362 void initPrograms (vk::SourceCollections& programCollection, const CaseDefinition caseDef) 363 { 364 // Vertex shader 365 { 366 std::ostringstream src; 367 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 368 << "\n" 369 << "layout(location = 0) in highp float in_v_attr;\n" 370 << "layout(location = 0) out highp float in_tc_attr;\n" 371 << "\n" 372 << "void main (void)\n" 373 << "{\n" 374 << " in_tc_attr = in_v_attr;\n" 375 << "}\n"; 376 377 programCollection.glslSources.add("vert") << glu::VertexSource(src.str()); 378 } 379 380 // Tessellation control shader 381 { 382 std::ostringstream src; 383 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 384 << "#extension GL_EXT_tessellation_shader : require\n" 385 << "\n" 386 << "layout(vertices = " << OUTPUT_PATCH_SIZE << ") out;\n" 387 << "\n" 388 << "layout(location = 0) in highp float in_tc_attr[];\n" 389 << "layout(location = 0) out highp float in_te_attr[];\n" 390 << "\n" 391 << (caseDef.caseType == CASETYPE_PRIMITIVE_ID_TCS ? "layout(location = 1) patch out mediump int in_te_primitiveIDFromTCS;\n" : 392 caseDef.caseType == CASETYPE_PATCH_VERTICES_IN_TCS ? "layout(location = 1) patch out mediump int in_te_patchVerticesInFromTCS;\n" : "") 393 << "\n" 394 << "void main (void)\n" 395 << "{\n" 396 << " in_te_attr[gl_InvocationID] = in_tc_attr[gl_InvocationID];\n" 397 << (caseDef.caseType == CASETYPE_PRIMITIVE_ID_TCS ? " in_te_primitiveIDFromTCS = gl_PrimitiveID;\n" : 398 caseDef.caseType == CASETYPE_PATCH_VERTICES_IN_TCS ? " in_te_patchVerticesInFromTCS = gl_PatchVerticesIn;\n" : "") 399 << "\n" 400 << " gl_TessLevelInner[0] = 9.0;\n" 401 << " gl_TessLevelInner[1] = 8.0;\n" 402 << "\n" 403 << " gl_TessLevelOuter[0] = 7.0;\n" 404 << " gl_TessLevelOuter[1] = 6.0;\n" 405 << " gl_TessLevelOuter[2] = 5.0;\n" 406 << " gl_TessLevelOuter[3] = 4.0;\n" 407 << "}\n"; 408 409 programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()); 410 } 411 412 // Tessellation evaluation shader 413 { 414 const float xScale = 1.0f / static_cast<float>(getNumPrimitives(caseDef.caseType)); 415 416 std::ostringstream src; 417 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 418 << "#extension GL_EXT_tessellation_shader : require\n" 419 << "\n" 420 << "layout(" << getTessPrimitiveTypeShaderName(TESSPRIMITIVETYPE_QUADS) << ") in;\n" 421 << "\n" 422 << "layout(location = 0) in highp float in_te_attr[];\n" 423 << "layout(location = 0) out mediump vec4 in_f_color;\n" 424 << "\n" 425 << (caseDef.caseType == CASETYPE_PRIMITIVE_ID_TCS ? "layout(location = 1) patch in mediump int in_te_primitiveIDFromTCS;\n" : 426 caseDef.caseType == CASETYPE_PATCH_VERTICES_IN_TCS ? "layout(location = 1) patch in mediump int in_te_patchVerticesInFromTCS;\n" : "") 427 << "\n" 428 << "void main (void)\n" 429 << "{\n" 430 << " highp float x = (gl_TessCoord.x*float(" << xScale << ") + in_te_attr[0]) * 2.0 - 1.0;\n" 431 << " highp float y = gl_TessCoord.y*2.0 - 1.0;\n" 432 << " gl_Position = vec4(x, y, 0.0, 1.0);\n" 433 << (caseDef.caseType == CASETYPE_PRIMITIVE_ID_TCS ? " bool ok = in_te_primitiveIDFromTCS == 3;\n" : 434 caseDef.caseType == CASETYPE_PRIMITIVE_ID_TES ? " bool ok = gl_PrimitiveID == 3;\n" : 435 caseDef.caseType == CASETYPE_PATCH_VERTICES_IN_TCS ? " bool ok = in_te_patchVerticesInFromTCS == " + de::toString(INPUT_PATCH_SIZE) + ";\n" : 436 caseDef.caseType == CASETYPE_PATCH_VERTICES_IN_TES ? " bool ok = gl_PatchVerticesIn == " + de::toString(OUTPUT_PATCH_SIZE) + ";\n" : 437 caseDef.caseType == CASETYPE_TESS_LEVEL_INNER0_TES ? " bool ok = abs(gl_TessLevelInner[0] - 9.0) < 0.1f;\n" : 438 caseDef.caseType == CASETYPE_TESS_LEVEL_INNER1_TES ? " bool ok = abs(gl_TessLevelInner[1] - 8.0) < 0.1f;\n" : 439 caseDef.caseType == CASETYPE_TESS_LEVEL_OUTER0_TES ? " bool ok = abs(gl_TessLevelOuter[0] - 7.0) < 0.1f;\n" : 440 caseDef.caseType == CASETYPE_TESS_LEVEL_OUTER1_TES ? " bool ok = abs(gl_TessLevelOuter[1] - 6.0) < 0.1f;\n" : 441 caseDef.caseType == CASETYPE_TESS_LEVEL_OUTER2_TES ? " bool ok = abs(gl_TessLevelOuter[2] - 5.0) < 0.1f;\n" : 442 caseDef.caseType == CASETYPE_TESS_LEVEL_OUTER3_TES ? " bool ok = abs(gl_TessLevelOuter[3] - 4.0) < 0.1f;\n" : "") 443 << " in_f_color = ok ? vec4(1.0) : vec4(vec3(0.0), 1.0);\n" 444 << "}\n"; 445 446 programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()); 447 } 448 449 // Fragment shader 450 { 451 std::ostringstream src; 452 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 453 << "\n" 454 << "layout(location = 0) in mediump vec4 in_f_color;\n" 455 << "layout(location = 0) out mediump vec4 o_color;\n" 456 << "\n" 457 << "void main (void)\n" 458 << "{\n" 459 << " o_color = in_f_color;\n" 460 << "}\n"; 461 462 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()); 463 } 464 } 465 466 //! Resize an image and fill with white color. 467 void initializeWhiteReferenceImage (tcu::TextureLevel& image, const int width, const int height) 468 { 469 DE_ASSERT(width > 0 && height > 0); 470 471 image.setStorage(mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM), width, height); 472 tcu::PixelBufferAccess access = image.getAccess(); 473 474 const tcu::Vec4 white(1.0f, 1.0f, 1.0f, 1.0f); 475 476 for (int y = 0; y < height; ++y) 477 for (int x = 0; x < width; ++x) 478 access.setPixel(white, x, y); 479 } 480 481 tcu::TestStatus test (Context& context, const CaseDefinition caseDef) 482 { 483 DE_ASSERT(!caseDef.usesReferenceImageFromFile || !caseDef.referenceImagePath.empty()); 484 485 // Input vertex attribute data 486 const int numPrimitives = getNumPrimitives(caseDef.caseType); 487 std::vector<float> vertexData (INPUT_PATCH_SIZE * numPrimitives, 0.0f); 488 const VkDeviceSize vertexBufferSize = sizeof(float) * vertexData.size(); 489 490 for (int i = 0; i < numPrimitives; ++i) 491 vertexData[INPUT_PATCH_SIZE * i] = static_cast<float>(i) / static_cast<float>(numPrimitives); 492 493 tcu::TextureLevel referenceImage; 494 if (caseDef.usesReferenceImageFromFile) 495 tcu::ImageIO::loadPNG(referenceImage, context.getTestContext().getArchive(), caseDef.referenceImagePath.c_str()); 496 else 497 initializeWhiteReferenceImage(referenceImage, RENDER_SIZE, RENDER_SIZE); 498 499 return runTest(context, numPrimitives, INPUT_PATCH_SIZE, OUTPUT_PATCH_SIZE, 500 VK_FORMAT_R32_SFLOAT, &vertexData[0], vertexBufferSize, referenceImage.getAccess()); 501 } 502 503 } // PerPatchData ns 504 505 namespace GLPosition 506 { 507 508 enum CaseType 509 { 510 CASETYPE_VS_TO_TCS = 0, 511 CASETYPE_TCS_TO_TES, 512 CASETYPE_VS_TO_TCS_TO_TES, 513 }; 514 515 void initPrograms (vk::SourceCollections& programCollection, const CaseType caseType) 516 { 517 const bool vsToTCS = caseType == CASETYPE_VS_TO_TCS || caseType == CASETYPE_VS_TO_TCS_TO_TES; 518 const bool tcsToTES = caseType == CASETYPE_TCS_TO_TES || caseType == CASETYPE_VS_TO_TCS_TO_TES; 519 520 // Vertex shader 521 { 522 std::ostringstream src; 523 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 524 << "\n" 525 << "layout(location = 0) in highp vec4 in_v_attr;\n" 526 << (!vsToTCS ? "layout(location = 0) out highp vec4 in_tc_attr;\n" : "") 527 << "\n" 528 << "void main (void)\n" 529 << "{\n" 530 << " " << (vsToTCS ? "gl_Position" : "in_tc_attr") << " = in_v_attr;\n" 531 << "}\n"; 532 533 programCollection.glslSources.add("vert") << glu::VertexSource(src.str()); 534 } 535 536 // Tessellation control shader 537 { 538 std::ostringstream src; 539 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 540 << "#extension GL_EXT_tessellation_shader : require\n" 541 << "\n" 542 << "layout(vertices = 3) out;\n" 543 << "\n" 544 << (!vsToTCS ? "layout(location = 0) in highp vec4 in_tc_attr[];\n" : "") 545 << (!tcsToTES ? "layout(location = 0) out highp vec4 in_te_attr[];\n" : "") 546 << "\n" 547 << "void main (void)\n" 548 << "{\n" 549 << " " << (tcsToTES ? "gl_out[gl_InvocationID].gl_Position" : "in_te_attr[gl_InvocationID]") << " = " 550 << (vsToTCS ? "gl_in[gl_InvocationID].gl_Position" : "in_tc_attr[gl_InvocationID]") << ";\n" 551 << "\n" 552 << " gl_TessLevelInner[0] = 2.0;\n" 553 << " gl_TessLevelInner[1] = 3.0;\n" 554 << "\n" 555 << " gl_TessLevelOuter[0] = 4.0;\n" 556 << " gl_TessLevelOuter[1] = 5.0;\n" 557 << " gl_TessLevelOuter[2] = 6.0;\n" 558 << " gl_TessLevelOuter[3] = 7.0;\n" 559 << "}\n"; 560 561 programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()); 562 } 563 564 // Tessellation evaluation shader 565 { 566 const std::string tesIn0 = tcsToTES ? "gl_in[0].gl_Position" : "in_te_attr[0]"; 567 const std::string tesIn1 = tcsToTES ? "gl_in[1].gl_Position" : "in_te_attr[1]"; 568 const std::string tesIn2 = tcsToTES ? "gl_in[2].gl_Position" : "in_te_attr[2]"; 569 570 std::ostringstream src; 571 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 572 << "#extension GL_EXT_tessellation_shader : require\n" 573 << "\n" 574 << "layout(" << getTessPrimitiveTypeShaderName(TESSPRIMITIVETYPE_TRIANGLES) << ") in;\n" 575 << "\n" 576 << (!tcsToTES ? "layout(location = 0) in highp vec4 in_te_attr[];\n" : "") 577 << "layout(location = 0) out highp vec4 in_f_color;\n" 578 << "\n" 579 << "void main (void)\n" 580 << "{\n" 581 << " highp vec2 xy = gl_TessCoord.x * " << tesIn0 << ".xy\n" 582 << " + gl_TessCoord.y * " << tesIn1 << ".xy\n" 583 << " + gl_TessCoord.z * " << tesIn2 << ".xy;\n" 584 << " gl_Position = vec4(xy, 0.0, 1.0);\n" 585 << " in_f_color = vec4(" << tesIn0 << ".z + " << tesIn1 << ".w,\n" 586 << " " << tesIn2 << ".z + " << tesIn0 << ".w,\n" 587 << " " << tesIn1 << ".z + " << tesIn2 << ".w,\n" 588 << " 1.0);\n" 589 << "}\n"; 590 591 programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()); 592 } 593 594 // Fragment shader 595 { 596 std::ostringstream src; 597 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 598 << "\n" 599 << "layout(location = 0) in highp vec4 in_f_color;\n" 600 << "layout(location = 0) out mediump vec4 o_color;\n" 601 << "\n" 602 << "void main (void)\n" 603 << "{\n" 604 << " o_color = in_f_color;\n" 605 << "}\n"; 606 607 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()); 608 } 609 } 610 611 tcu::TestStatus test (Context& context, const CaseType caseType) 612 { 613 DE_UNREF(caseType); 614 615 // Input vertex attribute data 616 static const float vertexData[3*4] = 617 { 618 -0.8f, -0.7f, 0.1f, 0.7f, 619 -0.5f, 0.4f, 0.2f, 0.5f, 620 0.3f, 0.2f, 0.3f, 0.45f 621 }; 622 623 tcu::TextureLevel referenceImage; 624 tcu::ImageIO::loadPNG(referenceImage, context.getTestContext().getArchive(), "vulkan/data/tessellation/gl_position_ref.png"); 625 626 const int numPrimitives = 1; 627 const int inPatchSize = 3; 628 const int outPatchSize = 3; 629 630 return runTest(context, numPrimitives, inPatchSize, outPatchSize, 631 VK_FORMAT_R32G32B32A32_SFLOAT, vertexData, sizeof(vertexData), referenceImage.getAccess()); 632 } 633 634 } // GLPosition ns 635 636 namespace Barrier 637 { 638 639 enum Constants 640 { 641 NUM_VERTICES = 32, 642 }; 643 644 void initPrograms (vk::SourceCollections& programCollection) 645 { 646 // Vertex shader 647 { 648 std::ostringstream src; 649 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 650 << "\n" 651 << "layout(location = 0) in highp float in_v_attr;\n" 652 << "layout(location = 0) out highp float in_tc_attr;\n" 653 << "\n" 654 << "void main (void)\n" 655 << "{\n" 656 << " in_tc_attr = in_v_attr;\n" 657 << "}\n"; 658 659 programCollection.glslSources.add("vert") << glu::VertexSource(src.str()); 660 } 661 662 // Tessellation control shader 663 { 664 std::ostringstream src; 665 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 666 << "#extension GL_EXT_tessellation_shader : require\n" 667 << "\n" 668 << "layout(vertices = " << NUM_VERTICES << ") out;\n" 669 << "\n" 670 << "layout(location = 0) in highp float in_tc_attr[];\n" 671 << "layout(location = 0) out highp float in_te_attr[];\n" 672 << "\n" 673 << "layout(location = 1) patch out highp float in_te_patchAttr;\n" 674 << "\n" 675 << "void main (void)\n" 676 << "{\n" 677 << " in_te_attr[gl_InvocationID] = in_tc_attr[gl_InvocationID];\n" 678 << " in_te_patchAttr = 0.0f;\n" 679 << "\n" 680 << " barrier();\n" 681 << "\n" 682 << " if (gl_InvocationID == 5)\n" 683 << " in_te_patchAttr = float(gl_InvocationID)*0.1;\n" 684 << "\n" 685 << " barrier();\n" 686 << "\n" 687 << " highp float temp = in_te_patchAttr + in_te_attr[gl_InvocationID];\n" 688 << "\n" 689 << " barrier();\n" 690 << "\n" 691 << " if (gl_InvocationID == " << NUM_VERTICES << "-1)\n" 692 << " in_te_patchAttr = float(gl_InvocationID);\n" 693 << "\n" 694 << " barrier();\n" 695 << "\n" 696 << " in_te_attr[gl_InvocationID] = temp;\n" 697 << "\n" 698 << " barrier();\n" 699 << "\n" 700 << " temp = temp + in_te_attr[(gl_InvocationID+1) % " << NUM_VERTICES << "];\n" 701 << "\n" 702 << " barrier();\n" 703 << "\n" 704 << " in_te_attr[gl_InvocationID] = 0.25*temp;\n" 705 << "\n" 706 << " gl_TessLevelInner[0] = 32.0;\n" 707 << " gl_TessLevelInner[1] = 32.0;\n" 708 << "\n" 709 << " gl_TessLevelOuter[0] = 32.0;\n" 710 << " gl_TessLevelOuter[1] = 32.0;\n" 711 << " gl_TessLevelOuter[2] = 32.0;\n" 712 << " gl_TessLevelOuter[3] = 32.0;\n" 713 << "}\n"; 714 715 programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()); 716 } 717 718 // Tessellation evaluation shader 719 { 720 std::ostringstream src; 721 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 722 << "#extension GL_EXT_tessellation_shader : require\n" 723 << "\n" 724 << "layout(" << getTessPrimitiveTypeShaderName(TESSPRIMITIVETYPE_QUADS) << ") in;\n" 725 << "\n" 726 << "layout(location = 0) in highp float in_te_attr[];\n" 727 << "layout(location = 1) patch in highp float in_te_patchAttr;\n" 728 << "\n" 729 << "layout(location = 0) out highp float in_f_blue;\n" 730 << "\n" 731 << "void main (void)\n" 732 << "{\n" 733 << " highp float x = gl_TessCoord.x*2.0 - 1.0;\n" 734 << " highp float y = gl_TessCoord.y - in_te_attr[int(round(gl_TessCoord.x*float(" << NUM_VERTICES << "-1)))];\n" 735 << " gl_Position = vec4(x, y, 0.0, 1.0);\n" 736 << " in_f_blue = abs(in_te_patchAttr - float(" << NUM_VERTICES << "-1));\n" 737 << "}\n"; 738 739 programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()); 740 } 741 742 // Fragment shader 743 { 744 std::ostringstream src; 745 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 746 << "\n" 747 << "layout(location = 0) in highp float in_f_blue;\n" 748 << "layout(location = 0) out mediump vec4 o_color;\n" 749 << "\n" 750 << "void main (void)\n" 751 << "{\n" 752 << " o_color = vec4(1.0, 0.0, in_f_blue, 1.0);\n" 753 << "}\n"; 754 755 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()); 756 } 757 } 758 759 tcu::TestStatus test (Context& context) 760 { 761 // Input vertex attribute data 762 std::vector<float> vertexData (NUM_VERTICES); 763 const VkDeviceSize vertexBufferSize = sizeof(float) * vertexData.size(); 764 765 for (int i = 0; i < NUM_VERTICES; ++i) 766 vertexData[i] = static_cast<float>(i) / (NUM_VERTICES - 1); 767 768 tcu::TextureLevel referenceImage; 769 tcu::ImageIO::loadPNG(referenceImage, context.getTestContext().getArchive(), "vulkan/data/tessellation/barrier_ref.png"); 770 771 const int numPrimitives = 1; 772 const int inPatchSize = NUM_VERTICES; 773 const int outPatchSize = NUM_VERTICES; 774 775 return runTest(context, numPrimitives, inPatchSize, outPatchSize, 776 VK_FORMAT_R32_SFLOAT, &vertexData[0], vertexBufferSize, referenceImage.getAccess()); 777 } 778 779 } // Barrier ns 780 781 } // anonymous 782 783 //! These tests correspond to dEQP-GLES31.functional.tessellation.shader_input_output.* 784 tcu::TestCaseGroup* createShaderInputOutputTests (tcu::TestContext& testCtx) 785 { 786 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "shader_input_output", "Test tessellation control and evaluation shader inputs and outputs")); 787 788 // Patch vertex counts 789 { 790 static const struct 791 { 792 int inPatchSize; 793 int outPatchSize; 794 } patchVertexCountCases[] = 795 { 796 { 5, 10 }, 797 { 10, 5 } 798 }; 799 800 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(patchVertexCountCases); caseNdx++) 801 { 802 const int inSize = patchVertexCountCases[caseNdx].inPatchSize; 803 const int outSize = patchVertexCountCases[caseNdx].outPatchSize; 804 805 const std::string caseName = "patch_vertices_" + de::toString(inSize) + "_in_" + de::toString(outSize) + "_out"; 806 const PatchVertexCount::CaseDefinition caseDef = 807 { 808 inSize, outSize, "vulkan/data/tessellation/" + caseName + "_ref.png" 809 }; 810 811 addFunctionCaseWithPrograms(group.get(), caseName, "Test input and output patch vertex counts", 812 PatchVertexCount::initPrograms, PatchVertexCount::test, caseDef); 813 } 814 } 815 816 // Per patch data 817 { 818 static const PerPatchData::CaseDefinition cases[] = 819 { 820 { PerPatchData::CASETYPE_PRIMITIVE_ID_TCS, "primitive_id_tcs", true, "vulkan/data/tessellation/primitive_id_tcs_ref.png", "Read gl_PrimitiveID in TCS and pass it as patch output to TES" }, 821 { PerPatchData::CASETYPE_PRIMITIVE_ID_TES, "primitive_id_tes", true, "vulkan/data/tessellation/primitive_id_tes_ref.png", "Read gl_PrimitiveID in TES" }, 822 { PerPatchData::CASETYPE_PATCH_VERTICES_IN_TCS, "patch_vertices_in_tcs", false, "", "Read gl_PatchVerticesIn in TCS and pass it as patch output to TES" }, 823 { PerPatchData::CASETYPE_PATCH_VERTICES_IN_TES, "patch_vertices_in_tes", false, "", "Read gl_PatchVerticesIn in TES" }, 824 { PerPatchData::CASETYPE_TESS_LEVEL_INNER0_TES, "tess_level_inner_0_tes", false, "", "Read gl_TessLevelInner[0] in TES" }, 825 { PerPatchData::CASETYPE_TESS_LEVEL_INNER1_TES, "tess_level_inner_1_tes", false, "", "Read gl_TessLevelInner[1] in TES" }, 826 { PerPatchData::CASETYPE_TESS_LEVEL_OUTER0_TES, "tess_level_outer_0_tes", false, "", "Read gl_TessLevelOuter[0] in TES" }, 827 { PerPatchData::CASETYPE_TESS_LEVEL_OUTER1_TES, "tess_level_outer_1_tes", false, "", "Read gl_TessLevelOuter[1] in TES" }, 828 { PerPatchData::CASETYPE_TESS_LEVEL_OUTER2_TES, "tess_level_outer_2_tes", false, "", "Read gl_TessLevelOuter[2] in TES" }, 829 { PerPatchData::CASETYPE_TESS_LEVEL_OUTER3_TES, "tess_level_outer_3_tes", false, "", "Read gl_TessLevelOuter[3] in TES" }, 830 }; 831 832 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); ++caseNdx) 833 addFunctionCaseWithPrograms(group.get(), cases[caseNdx].caseName, cases[caseNdx].caseDescription, 834 PerPatchData::initPrograms, PerPatchData::test, cases[caseNdx]); 835 } 836 837 // gl_Position 838 { 839 static const struct 840 { 841 GLPosition::CaseType type; 842 std::string caseName; 843 } cases[] = 844 { 845 { GLPosition::CASETYPE_VS_TO_TCS, "gl_position_vs_to_tcs" }, 846 { GLPosition::CASETYPE_TCS_TO_TES, "gl_position_tcs_to_tes" }, 847 { GLPosition::CASETYPE_VS_TO_TCS_TO_TES, "gl_position_vs_to_tcs_to_tes" }, 848 }; 849 850 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); ++caseNdx) 851 addFunctionCaseWithPrograms(group.get(), cases[caseNdx].caseName, "Pass gl_Position between VS and TCS, or between TCS and TES", 852 GLPosition::initPrograms, GLPosition::test, cases[caseNdx].type); 853 } 854 855 // Barrier 856 addFunctionCaseWithPrograms(group.get(), "barrier", "Basic barrier usage", Barrier::initPrograms, Barrier::test); 857 858 return group.release(); 859 } 860 861 } // tessellation 862 } // vkt 863
