1 /*------------------------------------------------------------------------ 2 * Vulkan Conformance Tests 3 * ------------------------ 4 * 5 * Copyright (c) 2016 The Khronos Group Inc. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Image Tests Utility Classes 22 *//*--------------------------------------------------------------------*/ 23 24 #include "vktImageTestsUtil.hpp" 25 #include "vkQueryUtil.hpp" 26 #include "vkTypeUtil.hpp" 27 #include "vkCmdUtil.hpp" 28 #include "vkObjUtil.hpp" 29 #include "tcuTextureUtil.hpp" 30 31 using namespace vk; 32 33 namespace vkt 34 { 35 namespace image 36 { 37 38 Buffer::Buffer (const DeviceInterface& vk, 39 const VkDevice device, 40 Allocator& allocator, 41 const VkBufferCreateInfo& bufferCreateInfo, 42 const MemoryRequirement memoryRequirement) 43 { 44 m_buffer = createBuffer(vk, device, &bufferCreateInfo); 45 m_allocation = allocator.allocate(getBufferMemoryRequirements(vk, device, *m_buffer), memoryRequirement); 46 VK_CHECK(vk.bindBufferMemory(device, *m_buffer, m_allocation->getMemory(), m_allocation->getOffset())); 47 } 48 49 Image::Image (const DeviceInterface& vk, 50 const VkDevice device, 51 Allocator& allocator, 52 const VkImageCreateInfo& imageCreateInfo, 53 const MemoryRequirement memoryRequirement) 54 { 55 m_image = createImage(vk, device, &imageCreateInfo); 56 m_allocation = allocator.allocate(getImageMemoryRequirements(vk, device, *m_image), memoryRequirement); 57 VK_CHECK(vk.bindImageMemory(device, *m_image, m_allocation->getMemory(), m_allocation->getOffset())); 58 } 59 60 tcu::UVec3 getShaderGridSize (const ImageType imageType, const tcu::UVec3& imageSize) 61 { 62 switch (imageType) 63 { 64 case IMAGE_TYPE_1D: 65 case IMAGE_TYPE_BUFFER: 66 return tcu::UVec3(imageSize.x(), 1u, 1u); 67 68 case IMAGE_TYPE_1D_ARRAY: 69 return tcu::UVec3(imageSize.x(), imageSize.z(), 1u); 70 71 case IMAGE_TYPE_2D: 72 return tcu::UVec3(imageSize.x(), imageSize.y(), 1u); 73 74 case IMAGE_TYPE_2D_ARRAY: 75 case IMAGE_TYPE_3D: 76 return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z()); 77 78 case IMAGE_TYPE_CUBE: 79 return tcu::UVec3(imageSize.x(), imageSize.y(), 6u); 80 81 case IMAGE_TYPE_CUBE_ARRAY: 82 return tcu::UVec3(imageSize.x(), imageSize.y(), 6u * imageSize.z()); 83 84 default: 85 DE_FATAL("Unknown image type"); 86 return tcu::UVec3(1u, 1u, 1u); 87 } 88 } 89 90 tcu::UVec3 getLayerSize (const ImageType imageType, const tcu::UVec3& imageSize) 91 { 92 switch (imageType) 93 { 94 case IMAGE_TYPE_1D: 95 case IMAGE_TYPE_1D_ARRAY: 96 case IMAGE_TYPE_BUFFER: 97 return tcu::UVec3(imageSize.x(), 1u, 1u); 98 99 case IMAGE_TYPE_2D: 100 case IMAGE_TYPE_2D_ARRAY: 101 case IMAGE_TYPE_CUBE: 102 case IMAGE_TYPE_CUBE_ARRAY: 103 return tcu::UVec3(imageSize.x(), imageSize.y(), 1u); 104 105 case IMAGE_TYPE_3D: 106 return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z()); 107 108 default: 109 DE_FATAL("Unknown image type"); 110 return tcu::UVec3(1u, 1u, 1u); 111 } 112 } 113 114 deUint32 getNumLayers (const ImageType imageType, const tcu::UVec3& imageSize) 115 { 116 switch (imageType) 117 { 118 case IMAGE_TYPE_1D: 119 case IMAGE_TYPE_2D: 120 case IMAGE_TYPE_3D: 121 case IMAGE_TYPE_BUFFER: 122 return 1u; 123 124 case IMAGE_TYPE_1D_ARRAY: 125 case IMAGE_TYPE_2D_ARRAY: 126 return imageSize.z(); 127 128 case IMAGE_TYPE_CUBE: 129 return 6u; 130 131 case IMAGE_TYPE_CUBE_ARRAY: 132 return imageSize.z() * 6u; 133 134 default: 135 DE_FATAL("Unknown image type"); 136 return 0u; 137 } 138 } 139 140 deUint32 getNumPixels (const ImageType imageType, const tcu::UVec3& imageSize) 141 { 142 const tcu::UVec3 gridSize = getShaderGridSize(imageType, imageSize); 143 144 return gridSize.x() * gridSize.y() * gridSize.z(); 145 } 146 147 deUint32 getDimensions (const ImageType imageType) 148 { 149 switch (imageType) 150 { 151 case IMAGE_TYPE_1D: 152 case IMAGE_TYPE_BUFFER: 153 return 1u; 154 155 case IMAGE_TYPE_1D_ARRAY: 156 case IMAGE_TYPE_2D: 157 return 2u; 158 159 case IMAGE_TYPE_2D_ARRAY: 160 case IMAGE_TYPE_CUBE: 161 case IMAGE_TYPE_CUBE_ARRAY: 162 case IMAGE_TYPE_3D: 163 return 3u; 164 165 default: 166 DE_FATAL("Unknown image type"); 167 return 0u; 168 } 169 } 170 171 deUint32 getLayerDimensions (const ImageType imageType) 172 { 173 switch (imageType) 174 { 175 case IMAGE_TYPE_1D: 176 case IMAGE_TYPE_BUFFER: 177 case IMAGE_TYPE_1D_ARRAY: 178 return 1u; 179 180 case IMAGE_TYPE_2D: 181 case IMAGE_TYPE_2D_ARRAY: 182 case IMAGE_TYPE_CUBE: 183 case IMAGE_TYPE_CUBE_ARRAY: 184 return 2u; 185 186 case IMAGE_TYPE_3D: 187 return 3u; 188 189 default: 190 DE_FATAL("Unknown image type"); 191 return 0u; 192 } 193 } 194 195 VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize bufferSize, 196 const VkBufferUsageFlags usage) 197 { 198 const VkBufferCreateInfo bufferCreateInfo = 199 { 200 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; 201 DE_NULL, // const void* pNext; 202 0u, // VkBufferCreateFlags flags; 203 bufferSize, // VkDeviceSize size; 204 usage, // VkBufferUsageFlags usage; 205 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 206 0u, // deUint32 queueFamilyIndexCount; 207 DE_NULL, // const deUint32* pQueueFamilyIndices; 208 }; 209 return bufferCreateInfo; 210 } 211 212 VkBufferImageCopy makeBufferImageCopy (const VkExtent3D extent, 213 const deUint32 arraySize) 214 { 215 const VkBufferImageCopy copyParams = 216 { 217 0ull, // VkDeviceSize bufferOffset; 218 0u, // deUint32 bufferRowLength; 219 0u, // deUint32 bufferImageHeight; 220 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, arraySize), // VkImageSubresourceLayers imageSubresource; 221 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset; 222 extent, // VkExtent3D imageExtent; 223 }; 224 return copyParams; 225 } 226 227 Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface& vk, 228 const VkDevice device, 229 const VkDescriptorSetLayout descriptorSetLayout) 230 { 231 const VkPipelineLayoutCreateInfo pipelineLayoutParams = 232 { 233 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; 234 DE_NULL, // const void* pNext; 235 0u, // VkPipelineLayoutCreateFlags flags; 236 1u, // deUint32 setLayoutCount; 237 &descriptorSetLayout, // const VkDescriptorSetLayout* pSetLayouts; 238 0u, // deUint32 pushConstantRangeCount; 239 DE_NULL, // const VkPushConstantRange* pPushConstantRanges; 240 }; 241 return createPipelineLayout(vk, device, &pipelineLayoutParams); 242 } 243 244 Move<VkPipeline> makeComputePipeline (const DeviceInterface& vk, 245 const VkDevice device, 246 const VkPipelineLayout pipelineLayout, 247 const VkShaderModule shaderModule) 248 { 249 const VkPipelineShaderStageCreateInfo pipelineShaderStageParams = 250 { 251 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 252 DE_NULL, // const void* pNext; 253 0u, // VkPipelineShaderStageCreateFlags flags; 254 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage; 255 shaderModule, // VkShaderModule module; 256 "main", // const char* pName; 257 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo; 258 }; 259 const VkComputePipelineCreateInfo pipelineCreateInfo = 260 { 261 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType; 262 DE_NULL, // const void* pNext; 263 0u, // VkPipelineCreateFlags flags; 264 pipelineShaderStageParams, // VkPipelineShaderStageCreateInfo stage; 265 pipelineLayout, // VkPipelineLayout layout; 266 DE_NULL, // VkPipeline basePipelineHandle; 267 0, // deInt32 basePipelineIndex; 268 }; 269 return createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo); 270 } 271 272 Move<VkPipeline> makeGraphicsPipeline (const DeviceInterface& vk, 273 const VkDevice device, 274 const VkPipelineLayout pipelineLayout, 275 const VkRenderPass renderPass, 276 const VkShaderModule vertexModule, 277 const VkShaderModule fragmentModule, 278 const VkExtent2D renderSize, 279 const deUint32 colorAttachmentCount, 280 const bool dynamicSize) 281 { 282 std::vector<VkViewport> viewports; 283 std::vector<VkRect2D> scissors; 284 285 const VkViewport viewport = makeViewport(renderSize); 286 const VkRect2D scissor = makeRect2D(renderSize); 287 288 const VkFormat vertexFormatPosition = VK_FORMAT_R32G32B32A32_SFLOAT; 289 const deUint32 vertexSizePosition = tcu::getPixelSize(mapVkFormat(vertexFormatPosition)); 290 const deUint32 vertexBufferOffsetPosition = 0u; 291 const deUint32 vertexDataStride = vertexSizePosition; 292 293 if (!dynamicSize) 294 { 295 viewports.push_back(viewport); 296 scissors.push_back(scissor); 297 } 298 299 const VkVertexInputBindingDescription vertexInputBindingDescription = 300 { 301 0u, // deUint32 binding; 302 vertexDataStride, // deUint32 stride; 303 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate; 304 }; 305 306 const VkVertexInputAttributeDescription vertexInputAttributeDescription = 307 { 308 0u, // deUint32 location; 309 0u, // deUint32 binding; 310 vertexFormatPosition, // VkFormat format; 311 vertexBufferOffsetPosition, // deUint32 offset; 312 }; 313 314 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo = 315 { 316 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType; 317 DE_NULL, // const void* pNext; 318 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags; 319 1u, // deUint32 vertexBindingDescriptionCount; 320 &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions; 321 1u, // deUint32 vertexAttributeDescriptionCount; 322 &vertexInputAttributeDescription // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 323 }; 324 325 const VkColorComponentFlags colorComponentsAll = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; 326 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState = 327 { 328 VK_FALSE, // VkBool32 blendEnable; 329 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor; 330 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor; 331 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp; 332 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor; 333 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor; 334 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp; 335 colorComponentsAll // VkColorComponentFlags colorWriteMask; 336 }; 337 338 std::vector<VkPipelineColorBlendAttachmentState> colorAttachments (colorAttachmentCount, colorBlendAttachmentState); 339 340 const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo = 341 { 342 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType; 343 DE_NULL, // const void* pNext; 344 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags; 345 VK_FALSE, // VkBool32 logicOpEnable; 346 VK_LOGIC_OP_COPY, // VkLogicOp logicOp; 347 (deUint32)colorAttachments.size(), // deUint32 attachmentCount; 348 colorAttachments.size() != 0 ? &colorAttachments[0] : DE_NULL, // const VkPipelineColorBlendAttachmentState* pAttachments; 349 { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4]; 350 }; 351 352 return vk::makeGraphicsPipeline(vk, // const DeviceInterface& vk 353 device, // const VkDevice device 354 pipelineLayout, // const VkPipelineLayout pipelineLayout 355 vertexModule, // const VkShaderModule vertexShaderModule 356 DE_NULL, // const VkShaderModule tessellationControlModule 357 DE_NULL, // const VkShaderModule tessellationEvalModule 358 DE_NULL, // const VkShaderModule geometryShaderModule 359 fragmentModule, // const VkShaderModule fragmentShaderModule 360 renderPass, // const VkRenderPass renderPass 361 viewports, // const std::vector<VkViewport>& viewports 362 scissors, // const std::vector<VkRect2D>& scissors 363 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // const VkPrimitiveTopology topology 364 0u, // const deUint32 subpass 365 0u, // const deUint32 patchControlPoints 366 &vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo 367 DE_NULL, // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo 368 DE_NULL, // const VkPipelineMultisampleStateCreateInfo* multisampleStateCreateInfo 369 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* depthStencilStateCreateInfo 370 &pipelineColorBlendStateInfo); // const VkPipelineColorBlendStateCreateInfo* colorBlendStateCreateInfo 371 } 372 373 //! A single-subpass render pass. 374 Move<VkRenderPass> makeRenderPass (const DeviceInterface& vk, 375 const VkDevice device, 376 const VkFormat inputFormat, 377 const VkFormat colorFormat) 378 { 379 const VkAttachmentReference inputAttachmentRef = 380 { 381 0u, // deUint32 attachment; 382 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout layout; 383 }; 384 385 const VkAttachmentReference colorAttachmentRef = 386 { 387 1u, // deUint32 attachment; 388 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; 389 }; 390 391 const VkSubpassDescription subpassDescription = 392 { 393 (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags; 394 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; 395 1u, // deUint32 inputAttachmentCount; 396 &inputAttachmentRef, // const VkAttachmentReference* pInputAttachments; 397 1u, // deUint32 colorAttachmentCount; 398 &colorAttachmentRef, // const VkAttachmentReference* pColorAttachments; 399 DE_NULL, // const VkAttachmentReference* pResolveAttachments; 400 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment; 401 0u, // deUint32 preserveAttachmentCount; 402 DE_NULL // const deUint32* pPreserveAttachments; 403 }; 404 405 const VkAttachmentDescription attachmentsDescriptions[] = 406 { 407 //inputAttachmentDescription, 408 { 409 (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags; 410 inputFormat, // VkFormat format; 411 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; 412 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp; 413 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp; 414 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; 415 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; 416 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout; 417 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout; 418 }, 419 //colorAttachmentDescription 420 { 421 (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags; 422 colorFormat, // VkFormat format; 423 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; 424 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; 425 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; 426 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; 427 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; 428 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; 429 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout; 430 } 431 }; 432 433 const VkRenderPassCreateInfo renderPassInfo = 434 { 435 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; 436 DE_NULL, // const void* pNext; 437 (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags; 438 DE_LENGTH_OF_ARRAY(attachmentsDescriptions), // deUint32 attachmentCount; 439 attachmentsDescriptions, // const VkAttachmentDescription* pAttachments; 440 1u, // deUint32 subpassCount; 441 &subpassDescription, // const VkSubpassDescription* pSubpasses; 442 0u, // deUint32 dependencyCount; 443 DE_NULL // const VkSubpassDependency* pDependencies; 444 }; 445 446 return createRenderPass(vk, device, &renderPassInfo); 447 } 448 449 //! A single-subpass render pass. 450 Move<VkRenderPass> makeRenderPass (const DeviceInterface& vk, 451 const VkDevice device) 452 { 453 const VkSubpassDescription subpassDescription = 454 { 455 (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags; 456 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; 457 0u, // deUint32 inputAttachmentCount; 458 DE_NULL, // const VkAttachmentReference* pInputAttachments; 459 0u, // deUint32 colorAttachmentCount; 460 DE_NULL, // const VkAttachmentReference* pColorAttachments; 461 DE_NULL, // const VkAttachmentReference* pResolveAttachments; 462 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment; 463 0u, // deUint32 preserveAttachmentCount; 464 DE_NULL // const deUint32* pPreserveAttachments; 465 }; 466 467 const VkRenderPassCreateInfo renderPassInfo = 468 { 469 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; 470 DE_NULL, // const void* pNext; 471 (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags; 472 0, // deUint32 attachmentCount; 473 DE_NULL, // const VkAttachmentDescription* pAttachments; 474 1u, // deUint32 subpassCount; 475 &subpassDescription, // const VkSubpassDescription* pSubpasses; 476 0u, // deUint32 dependencyCount; 477 DE_NULL // const VkSubpassDependency* pDependencies; 478 }; 479 480 return createRenderPass(vk, device, &renderPassInfo); 481 } 482 483 Move<VkBufferView> makeBufferView (const DeviceInterface& vk, 484 const VkDevice vkDevice, 485 const VkBuffer buffer, 486 const VkFormat format, 487 const VkDeviceSize offset, 488 const VkDeviceSize size) 489 { 490 const VkBufferViewCreateInfo bufferViewParams = 491 { 492 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, // VkStructureType sType; 493 DE_NULL, // const void* pNext; 494 0u, // VkBufferViewCreateFlags flags; 495 buffer, // VkBuffer buffer; 496 format, // VkFormat format; 497 offset, // VkDeviceSize offset; 498 size, // VkDeviceSize range; 499 }; 500 return createBufferView(vk, vkDevice, &bufferViewParams); 501 } 502 503 Move<VkImageView> makeImageView (const DeviceInterface& vk, 504 const VkDevice vkDevice, 505 const VkImage image, 506 const VkImageViewType imageViewType, 507 const VkFormat format, 508 const VkImageSubresourceRange subresourceRange, 509 const VkImageViewUsageCreateInfo* ImageUsageCreateInfo) 510 { 511 const VkImageViewCreateInfo imageViewParams = 512 { 513 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType; 514 ImageUsageCreateInfo, // const void* pNext; 515 0u, // VkImageViewCreateFlags flags; 516 image, // VkImage image; 517 imageViewType, // VkImageViewType viewType; 518 format, // VkFormat format; 519 makeComponentMappingRGBA(), // VkComponentMapping components; 520 subresourceRange, // VkImageSubresourceRange subresourceRange; 521 }; 522 return createImageView(vk, vkDevice, &imageViewParams); 523 } 524 525 Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface& vk, 526 const VkDevice device, 527 const VkDescriptorPool descriptorPool, 528 const VkDescriptorSetLayout setLayout) 529 { 530 const VkDescriptorSetAllocateInfo allocateParams = 531 { 532 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType; 533 DE_NULL, // const void* pNext; 534 descriptorPool, // VkDescriptorPool descriptorPool; 535 1u, // deUint32 setLayoutCount; 536 &setLayout, // const VkDescriptorSetLayout* pSetLayouts; 537 }; 538 return allocateDescriptorSet(vk, device, &allocateParams); 539 } 540 541 VkImageViewUsageCreateInfo makeImageViewUsageCreateInfo (const VkImageUsageFlags imageUsageFlags) 542 { 543 VkImageViewUsageCreateInfo imageViewUsageCreateInfo = 544 { 545 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, //VkStructureType sType; 546 DE_NULL, //const void* pNext; 547 imageUsageFlags, //VkImageUsageFlags usage; 548 }; 549 550 return imageViewUsageCreateInfo; 551 } 552 553 VkSamplerCreateInfo makeSamplerCreateInfo () 554 { 555 const VkSamplerCreateInfo defaultSamplerParams = 556 { 557 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType; 558 DE_NULL, // const void* pNext; 559 0u, // VkSamplerCreateFlags flags; 560 VK_FILTER_NEAREST, // VkFilter magFilter; 561 VK_FILTER_NEAREST, // VkFilter minFilter; 562 VK_SAMPLER_MIPMAP_MODE_NEAREST, // VkSamplerMipmapMode mipmapMode; 563 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeU; 564 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeV; 565 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeW; 566 0.0f, // float mipLodBias; 567 VK_FALSE, // VkBool32 anisotropyEnable; 568 1.0f, // float maxAnisotropy; 569 VK_FALSE, // VkBool32 compareEnable; 570 VK_COMPARE_OP_NEVER, // VkCompareOp compareOp; 571 0.0f, // float minLod; 572 0.25f, // float maxLod; 573 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // VkBorderColor borderColor; 574 VK_FALSE // VkBool32 unnormalizedCoordinates; 575 }; 576 577 return defaultSamplerParams; 578 } 579 580 tcu::UVec3 getCompressedImageResolutionInBlocks (const vk::VkFormat format, const tcu::UVec3& size) 581 { 582 deUint32 blockWidth = getBlockWidth(format); 583 deUint32 blockHeight = getBlockHeight(format); 584 585 DE_ASSERT(size[2] == 1); 586 DE_ASSERT(blockWidth != 0 && blockHeight != 0); 587 588 deUint32 widthInBlocks = (size[0] + blockWidth - 1) / blockWidth; 589 deUint32 heightInBlocks = (size[1] + blockHeight - 1) / blockHeight; 590 591 return tcu::UVec3(widthInBlocks, heightInBlocks, 1); 592 } 593 594 tcu::UVec3 getCompressedImageResolutionBlockCeil (const vk::VkFormat format, const tcu::UVec3& size) 595 { 596 deUint32 blockWidth = getBlockWidth(format); 597 deUint32 blockHeight = getBlockHeight(format); 598 599 DE_ASSERT(size[2] == 1); 600 DE_ASSERT(blockWidth != 0 && blockHeight != 0); 601 602 deUint32 widthInBlocks = (size[0] + blockWidth - 1) / blockWidth; 603 deUint32 heightInBlocks = (size[1] + blockHeight - 1) / blockHeight; 604 605 return tcu::UVec3(blockWidth * widthInBlocks, blockHeight * heightInBlocks, 1); 606 } 607 608 VkDeviceSize getCompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size) 609 { 610 tcu::UVec3 sizeInBlocks = getCompressedImageResolutionInBlocks(format, size); 611 deUint32 blockBytes = getBlockSizeInBytes(format); 612 VkDeviceSize sizeBytes = sizeInBlocks[0] * sizeInBlocks[1] * sizeInBlocks[2] * blockBytes; 613 614 return sizeBytes; 615 } 616 617 VkDeviceSize getUncompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size) 618 { 619 const tcu::IVec3 sizeAsIVec3 = tcu::IVec3((int)size.x(), (int)size.y(), (int)size.z()); 620 const VkDeviceSize sizeBytes = getImageSizeBytes(sizeAsIVec3, format); 621 622 return sizeBytes; 623 } 624 625 VkImageType mapImageType (const ImageType imageType) 626 { 627 switch (imageType) 628 { 629 case IMAGE_TYPE_1D: 630 case IMAGE_TYPE_1D_ARRAY: 631 case IMAGE_TYPE_BUFFER: 632 return VK_IMAGE_TYPE_1D; 633 634 case IMAGE_TYPE_2D: 635 case IMAGE_TYPE_2D_ARRAY: 636 case IMAGE_TYPE_CUBE: 637 case IMAGE_TYPE_CUBE_ARRAY: 638 return VK_IMAGE_TYPE_2D; 639 640 case IMAGE_TYPE_3D: 641 return VK_IMAGE_TYPE_3D; 642 643 default: 644 DE_ASSERT(false); 645 return VK_IMAGE_TYPE_LAST; 646 } 647 } 648 649 VkImageViewType mapImageViewType (const ImageType imageType) 650 { 651 switch (imageType) 652 { 653 case IMAGE_TYPE_1D: return VK_IMAGE_VIEW_TYPE_1D; 654 case IMAGE_TYPE_1D_ARRAY: return VK_IMAGE_VIEW_TYPE_1D_ARRAY; 655 case IMAGE_TYPE_2D: return VK_IMAGE_VIEW_TYPE_2D; 656 case IMAGE_TYPE_2D_ARRAY: return VK_IMAGE_VIEW_TYPE_2D_ARRAY; 657 case IMAGE_TYPE_3D: return VK_IMAGE_VIEW_TYPE_3D; 658 case IMAGE_TYPE_CUBE: return VK_IMAGE_VIEW_TYPE_CUBE; 659 case IMAGE_TYPE_CUBE_ARRAY: return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; 660 661 default: 662 DE_ASSERT(false); 663 return VK_IMAGE_VIEW_TYPE_LAST; 664 } 665 } 666 667 std::string getImageTypeName (const ImageType imageType) 668 { 669 switch (imageType) 670 { 671 case IMAGE_TYPE_1D: return "1d"; 672 case IMAGE_TYPE_1D_ARRAY: return "1d_array"; 673 case IMAGE_TYPE_2D: return "2d"; 674 case IMAGE_TYPE_2D_ARRAY: return "2d_array"; 675 case IMAGE_TYPE_3D: return "3d"; 676 case IMAGE_TYPE_CUBE: return "cube"; 677 case IMAGE_TYPE_CUBE_ARRAY: return "cube_array"; 678 case IMAGE_TYPE_BUFFER: return "buffer"; 679 680 default: 681 DE_ASSERT(false); 682 return ""; 683 } 684 } 685 686 std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType, const bool multisample) 687 { 688 std::string formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" : 689 tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER ? "i" : ""; 690 691 std::string imageTypePart; 692 if (multisample) 693 { 694 switch (imageType) 695 { 696 case IMAGE_TYPE_2D: imageTypePart = "2DMS"; break; 697 case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DMSArray"; break; 698 699 default: 700 DE_ASSERT(false); 701 } 702 } 703 else 704 { 705 switch (imageType) 706 { 707 case IMAGE_TYPE_1D: imageTypePart = "1D"; break; 708 case IMAGE_TYPE_1D_ARRAY: imageTypePart = "1DArray"; break; 709 case IMAGE_TYPE_2D: imageTypePart = "2D"; break; 710 case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DArray"; break; 711 case IMAGE_TYPE_3D: imageTypePart = "3D"; break; 712 case IMAGE_TYPE_CUBE: imageTypePart = "Cube"; break; 713 case IMAGE_TYPE_CUBE_ARRAY: imageTypePart = "CubeArray"; break; 714 case IMAGE_TYPE_BUFFER: imageTypePart = "Buffer"; break; 715 716 default: 717 DE_ASSERT(false); 718 } 719 } 720 721 return formatPart + "image" + imageTypePart; 722 } 723 724 std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format) 725 { 726 const char* orderPart; 727 const char* typePart; 728 729 switch (format.order) 730 { 731 case tcu::TextureFormat::R: orderPart = "r"; break; 732 case tcu::TextureFormat::RG: orderPart = "rg"; break; 733 case tcu::TextureFormat::RGB: orderPart = "rgb"; break; 734 case tcu::TextureFormat::RGBA: orderPart = "rgba"; break; 735 case tcu::TextureFormat::sRGBA: orderPart = "rgba"; break; 736 737 default: 738 DE_ASSERT(false); 739 orderPart = DE_NULL; 740 } 741 742 switch (format.type) 743 { 744 case tcu::TextureFormat::FLOAT: typePart = "32f"; break; 745 case tcu::TextureFormat::HALF_FLOAT: typePart = "16f"; break; 746 747 case tcu::TextureFormat::UNSIGNED_INT32: typePart = "32ui"; break; 748 case tcu::TextureFormat::UNSIGNED_INT16: typePart = "16ui"; break; 749 case tcu::TextureFormat::UNSIGNED_INT8: typePart = "8ui"; break; 750 751 case tcu::TextureFormat::SIGNED_INT32: typePart = "32i"; break; 752 case tcu::TextureFormat::SIGNED_INT16: typePart = "16i"; break; 753 case tcu::TextureFormat::SIGNED_INT8: typePart = "8i"; break; 754 755 case tcu::TextureFormat::UNORM_INT16: typePart = "16"; break; 756 case tcu::TextureFormat::UNORM_INT8: typePart = "8"; break; 757 758 case tcu::TextureFormat::SNORM_INT16: typePart = "16_snorm"; break; 759 case tcu::TextureFormat::SNORM_INT8: typePart = "8_snorm"; break; 760 761 default: 762 DE_ASSERT(false); 763 typePart = DE_NULL; 764 } 765 766 return std::string() + orderPart + typePart; 767 } 768 769 std::string getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type) 770 { 771 const char* typePart = DE_NULL; 772 const char* formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" : 773 tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER ? "i" : ""; 774 775 switch (type) 776 { 777 case VK_IMAGE_VIEW_TYPE_1D: typePart = "sampler1D"; break; 778 case VK_IMAGE_VIEW_TYPE_1D_ARRAY: typePart = "sampler1DArray"; break; 779 case VK_IMAGE_VIEW_TYPE_2D: typePart = "sampler2D"; break; 780 case VK_IMAGE_VIEW_TYPE_2D_ARRAY: typePart = "sampler2DArray"; break; 781 case VK_IMAGE_VIEW_TYPE_3D: typePart = "sampler3D"; break; 782 case VK_IMAGE_VIEW_TYPE_CUBE: typePart = "samplerCube"; break; 783 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: typePart = "samplerCubeArray"; break; 784 785 default: 786 DE_FATAL("Unknown image view type"); 787 break; 788 } 789 790 return std::string(formatPart) + typePart; 791 } 792 793 794 const char* getGlslInputFormatType (const vk::VkFormat format) 795 { 796 switch (format) 797 { 798 // 64-bit 799 case VK_FORMAT_R16G16B16A16_UNORM: return "subpassInput"; 800 case VK_FORMAT_R16G16B16A16_SNORM: return "subpassInput"; 801 case VK_FORMAT_R16G16B16A16_USCALED: return "subpassInput"; 802 case VK_FORMAT_R16G16B16A16_SSCALED: return "subpassInput"; 803 case VK_FORMAT_R16G16B16A16_UINT: return "usubpassInput"; 804 case VK_FORMAT_R16G16B16A16_SINT: return "isubpassInput"; 805 case VK_FORMAT_R16G16B16A16_SFLOAT: return "subpassInput"; 806 case VK_FORMAT_R32G32_UINT: return "usubpassInput"; 807 case VK_FORMAT_R32G32_SINT: return "isubpassInput"; 808 case VK_FORMAT_R32G32_SFLOAT: return "subpassInput"; 809 // TODO: case VK_FORMAT_R64_UINT: return "usubpassInput"; 810 // TODO: case VK_FORMAT_R64_SINT: return "isubpassInput"; 811 // TODO: case VK_FORMAT_R64_SFLOAT: return "subpassInput"; 812 813 // 128-bit 814 case VK_FORMAT_R32G32B32A32_UINT: return "usubpassInput"; 815 case VK_FORMAT_R32G32B32A32_SINT: return "isubpassInput"; 816 case VK_FORMAT_R32G32B32A32_SFLOAT: return "subpassInput"; 817 // TODO: case VK_FORMAT_R64G64_UINT: return "usubpassInput"; 818 // TODO: case VK_FORMAT_R64G64_SINT: return "isubpassInput"; 819 // TODO: case VK_FORMAT_R64G64_SFLOAT: return "subpassInput"; 820 821 default: TCU_THROW(InternalError, "Unknown format"); 822 } 823 } 824 825 const char* getGlslFormatType (const vk::VkFormat format) 826 { 827 switch (format) 828 { 829 // 64-bit 830 case VK_FORMAT_R16G16B16A16_UNORM: return "vec4"; 831 case VK_FORMAT_R16G16B16A16_SNORM: return "vec4"; 832 case VK_FORMAT_R16G16B16A16_USCALED: return "vec4"; 833 case VK_FORMAT_R16G16B16A16_SSCALED: return "vec4"; 834 case VK_FORMAT_R16G16B16A16_UINT: return "uvec4"; 835 case VK_FORMAT_R16G16B16A16_SINT: return "ivec4"; 836 case VK_FORMAT_R16G16B16A16_SFLOAT: return "vec4"; 837 case VK_FORMAT_R32G32_UINT: return "uvec2"; 838 case VK_FORMAT_R32G32_SINT: return "ivec2"; 839 case VK_FORMAT_R32G32_SFLOAT: return "vec2"; 840 // TODO: case VK_FORMAT_R64_UINT: return "uint64"; 841 // TODO: case VK_FORMAT_R64_SINT: return "int64"; 842 // TODO: case VK_FORMAT_R64_SFLOAT: return "double"; 843 844 // 128-bit 845 case VK_FORMAT_R32G32B32A32_UINT: return "uvec4"; 846 case VK_FORMAT_R32G32B32A32_SINT: return "ivec4"; 847 case VK_FORMAT_R32G32B32A32_SFLOAT: return "vec4"; 848 // TODO: case VK_FORMAT_R64G64_UINT: return "ulvec2"; 849 // TODO: case VK_FORMAT_R64G64_SINT: return "ilvec2"; 850 // TODO: case VK_FORMAT_R64G64_SFLOAT: return "dvec2"; 851 852 default: TCU_THROW(InternalError, "Unknown format"); 853 } 854 } 855 856 const char* getGlslAttachmentType (const vk::VkFormat format) 857 { 858 const tcu::TextureFormat textureFormat = mapVkFormat(format); 859 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(textureFormat.type); 860 861 switch (channelClass) 862 { 863 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 864 return "ivec4"; 865 866 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 867 return "uvec4"; 868 869 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: 870 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 871 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 872 return "vec4"; 873 874 default: 875 DE_FATAL("Unknown channel class"); 876 return ""; 877 } 878 } 879 880 const char* getGlslInputAttachmentType (const vk::VkFormat format) 881 { 882 const tcu::TextureFormat textureFormat = mapVkFormat(format); 883 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(textureFormat.type); 884 885 switch (channelClass) 886 { 887 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 888 return "isubpassInput"; 889 890 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 891 return "usubpassInput"; 892 893 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: 894 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 895 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 896 return "subpassInput"; 897 898 default: 899 DE_FATAL("Unknown channel class"); 900 return ""; 901 } 902 } 903 904 bool isPackedType (const vk::VkFormat format) 905 { 906 const tcu::TextureFormat textureFormat = mapVkFormat(format); 907 908 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST == 40); 909 910 switch (textureFormat.type) 911 { 912 case tcu::TextureFormat::UNORM_BYTE_44: 913 case tcu::TextureFormat::UNORM_SHORT_565: 914 case tcu::TextureFormat::UNORM_SHORT_555: 915 case tcu::TextureFormat::UNORM_SHORT_4444: 916 case tcu::TextureFormat::UNORM_SHORT_5551: 917 case tcu::TextureFormat::UNORM_SHORT_1555: 918 case tcu::TextureFormat::UNORM_INT_101010: 919 case tcu::TextureFormat::SNORM_INT_1010102_REV: 920 case tcu::TextureFormat::UNORM_INT_1010102_REV: 921 case tcu::TextureFormat::UNSIGNED_BYTE_44: 922 case tcu::TextureFormat::UNSIGNED_SHORT_565: 923 case tcu::TextureFormat::UNSIGNED_SHORT_4444: 924 case tcu::TextureFormat::UNSIGNED_SHORT_5551: 925 case tcu::TextureFormat::SIGNED_INT_1010102_REV: 926 case tcu::TextureFormat::UNSIGNED_INT_1010102_REV: 927 case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: 928 case tcu::TextureFormat::UNSIGNED_INT_999_E5_REV: 929 case tcu::TextureFormat::UNSIGNED_INT_16_8_8: 930 case tcu::TextureFormat::UNSIGNED_INT_24_8: 931 case tcu::TextureFormat::UNSIGNED_INT_24_8_REV: 932 return true; 933 934 default: 935 return false; 936 } 937 } 938 939 bool isComponentSwizzled (const vk::VkFormat format) 940 { 941 const tcu::TextureFormat textureFormat = mapVkFormat(format); 942 943 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21); 944 945 switch (textureFormat.order) 946 { 947 case tcu::TextureFormat::ARGB: 948 case tcu::TextureFormat::BGR: 949 case tcu::TextureFormat::BGRA: 950 case tcu::TextureFormat::sBGR: 951 case tcu::TextureFormat::sBGRA: 952 return true; 953 954 default: 955 return false; 956 } 957 } 958 959 int getNumUsedChannels (const vk::VkFormat format) 960 { 961 // make sure this function will be checked if type table is updated 962 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21); 963 964 const tcu::TextureFormat textureFormat = mapVkFormat(format); 965 966 return getNumUsedChannels(textureFormat.order); 967 } 968 969 bool isFormatImageLoadStoreCapable (const vk::VkFormat format) 970 { 971 // These come from https://www.khronos.org/registry/vulkan/specs/1.1/html/vkspec.html#spirvenv-image-formats 972 switch (format) 973 { 974 case VK_FORMAT_R32G32B32A32_SFLOAT: 975 case VK_FORMAT_R16G16B16A16_SFLOAT: 976 case VK_FORMAT_R32_SFLOAT: 977 case VK_FORMAT_R8G8B8A8_UNORM: 978 case VK_FORMAT_R8G8B8A8_SNORM: 979 case VK_FORMAT_R32G32_SFLOAT: 980 case VK_FORMAT_R16G16_SFLOAT: 981 case VK_FORMAT_B10G11R11_UFLOAT_PACK32: 982 case VK_FORMAT_R16_SFLOAT: 983 case VK_FORMAT_R16G16B16A16_UNORM: 984 case VK_FORMAT_A2B10G10R10_UNORM_PACK32: 985 case VK_FORMAT_R16G16_UNORM: 986 case VK_FORMAT_R8G8_UNORM: 987 case VK_FORMAT_R16_UNORM: 988 case VK_FORMAT_R8_UNORM: 989 case VK_FORMAT_R16G16B16A16_SNORM: 990 case VK_FORMAT_R16G16_SNORM: 991 case VK_FORMAT_R8G8_SNORM: 992 case VK_FORMAT_R16_SNORM: 993 case VK_FORMAT_R8_SNORM: 994 case VK_FORMAT_R32G32B32A32_SINT: 995 case VK_FORMAT_R16G16B16A16_SINT: 996 case VK_FORMAT_R8G8B8A8_SINT: 997 case VK_FORMAT_R32_SINT: 998 case VK_FORMAT_R32G32_SINT: 999 case VK_FORMAT_R16G16_SINT: 1000 case VK_FORMAT_R8G8_SINT: 1001 case VK_FORMAT_R16_SINT: 1002 case VK_FORMAT_R8_SINT: 1003 case VK_FORMAT_R32G32B32A32_UINT: 1004 case VK_FORMAT_R16G16B16A16_UINT: 1005 case VK_FORMAT_R8G8B8A8_UINT: 1006 case VK_FORMAT_R32_UINT: 1007 case VK_FORMAT_A2B10G10R10_UINT_PACK32: 1008 case VK_FORMAT_R32G32_UINT: 1009 case VK_FORMAT_R16G16_UINT: 1010 case VK_FORMAT_R8G8_UINT: 1011 case VK_FORMAT_R16_UINT: 1012 case VK_FORMAT_R8_UINT: 1013 return true; 1014 1015 default: 1016 return false; 1017 } 1018 } 1019 1020 std::string getFormatShortString (const VkFormat format) 1021 { 1022 const std::string fullName = getFormatName(format); 1023 1024 DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_")); 1025 1026 return de::toLower(fullName.substr(10)); 1027 } 1028 1029 std::vector<tcu::Vec4> createFullscreenQuad (void) 1030 { 1031 const tcu::Vec4 lowerLeftVertex (-1.0f, -1.0f, 0.0f, 1.0f); 1032 const tcu::Vec4 upperLeftVertex (-1.0f, 1.0f, 0.0f, 1.0f); 1033 const tcu::Vec4 lowerRightVertex (1.0f, -1.0f, 0.0f, 1.0f); 1034 const tcu::Vec4 upperRightVertex (1.0f, 1.0f, 0.0f, 1.0f); 1035 1036 const tcu::Vec4 vertices[6] = 1037 { 1038 lowerLeftVertex, 1039 lowerRightVertex, 1040 upperLeftVertex, 1041 1042 upperLeftVertex, 1043 lowerRightVertex, 1044 upperRightVertex 1045 }; 1046 1047 return std::vector<tcu::Vec4>(vertices, vertices + DE_LENGTH_OF_ARRAY(vertices)); 1048 } 1049 1050 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer) 1051 { 1052 const VkBufferImageCopy copyParams = 1053 { 1054 (VkDeviceSize)0u, // bufferOffset 1055 imageWidth, // bufferRowLength 1056 imageHeight, // bufferImageHeight 1057 { 1058 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask 1059 mipLevel, // mipLevel 1060 layer, // baseArrayLayer 1061 1u, // layerCount 1062 }, // imageSubresource 1063 { 0u, 0u, 0u }, // imageOffset 1064 { 1065 imageWidth, 1066 imageHeight, 1067 1u 1068 } // imageExtent 1069 }; 1070 1071 return copyParams; 1072 } 1073 1074 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer, const deUint32 bufferRowLength, const deUint32 bufferImageHeight) 1075 { 1076 const VkBufferImageCopy copyParams = 1077 { 1078 (VkDeviceSize)0u, // bufferOffset 1079 bufferRowLength, // bufferRowLength 1080 bufferImageHeight, // bufferImageHeight 1081 { 1082 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask 1083 mipLevel, // mipLevel 1084 layer, // baseArrayLayer 1085 1u, // layerCount 1086 }, // imageSubresource 1087 { 0u, 0u, 0u }, // imageOffset 1088 { 1089 imageWidth, 1090 imageHeight, 1091 1u 1092 } // imageExtent 1093 }; 1094 1095 return copyParams; 1096 } 1097 1098 void beginRenderPass (const DeviceInterface& vk, 1099 const VkCommandBuffer commandBuffer, 1100 const VkRenderPass renderPass, 1101 const VkFramebuffer framebuffer, 1102 const VkExtent2D& renderSize) 1103 { 1104 const VkRect2D renderArea = 1105 { 1106 {0, 0}, // VkOffset2D offset; 1107 renderSize, // VkExtent2D extent; 1108 }; 1109 1110 beginRenderPass(vk, commandBuffer, renderPass, framebuffer, renderArea, tcu::Vec4(0.0f), 0.0f, 0u); 1111 } 1112 1113 Move<VkFramebuffer> makeFramebuffer (const DeviceInterface& vk, 1114 const VkDevice device, 1115 const VkRenderPass renderPass, 1116 const deUint32 attachmentCount, 1117 const VkImageView* pAttachments, 1118 const VkExtent2D& size, 1119 const deUint32 layersCount) 1120 { 1121 const vk::VkFramebufferCreateInfo framebufferInfo = 1122 { 1123 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; 1124 DE_NULL, // const void* pNext; 1125 (VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags; 1126 renderPass, // VkRenderPass renderPass; 1127 attachmentCount, // uint32_t attachmentCount; 1128 pAttachments, // const VkImageView* pAttachments; 1129 static_cast<deUint32>(size.width), // uint32_t width; 1130 static_cast<deUint32>(size.height), // uint32_t height; 1131 layersCount, // uint32_t layers; 1132 }; 1133 1134 return createFramebuffer(vk, device, &framebufferInfo); 1135 } 1136 1137 } // image 1138 } // vkt 1139
