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 Object creation utilities 22 *//*--------------------------------------------------------------------*/ 23 24 #include "vktFragmentOperationsMakeUtil.hpp" 25 #include "vkTypeUtil.hpp" 26 #include "vkPrograms.hpp" 27 #include "vkQueryUtil.hpp" 28 #include <vector> 29 30 namespace vkt 31 { 32 namespace FragmentOperations 33 { 34 using namespace vk; 35 using de::MovePtr; 36 37 VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize bufferSize, 38 const VkBufferUsageFlags usage) 39 { 40 const VkBufferCreateInfo bufferCreateInfo = 41 { 42 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; 43 DE_NULL, // const void* pNext; 44 (VkBufferCreateFlags)0, // VkBufferCreateFlags flags; 45 bufferSize, // VkDeviceSize size; 46 usage, // VkBufferUsageFlags usage; 47 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 48 0u, // deUint32 queueFamilyIndexCount; 49 DE_NULL, // const deUint32* pQueueFamilyIndices; 50 }; 51 return bufferCreateInfo; 52 } 53 54 VkBufferMemoryBarrier makeBufferMemoryBarrier (const VkAccessFlags srcAccessMask, 55 const VkAccessFlags dstAccessMask, 56 const VkBuffer buffer, 57 const VkDeviceSize offset, 58 const VkDeviceSize bufferSizeBytes) 59 { 60 const VkBufferMemoryBarrier barrier = 61 { 62 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType; 63 DE_NULL, // const void* pNext; 64 srcAccessMask, // VkAccessFlags srcAccessMask; 65 dstAccessMask, // VkAccessFlags dstAccessMask; 66 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex; 67 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex; 68 buffer, // VkBuffer buffer; 69 offset, // VkDeviceSize offset; 70 bufferSizeBytes, // VkDeviceSize size; 71 }; 72 return barrier; 73 } 74 75 VkImageMemoryBarrier makeImageMemoryBarrier (const VkAccessFlags srcAccessMask, 76 const VkAccessFlags dstAccessMask, 77 const VkImageLayout oldLayout, 78 const VkImageLayout newLayout, 79 const VkImage image, 80 const VkImageSubresourceRange subresourceRange) 81 { 82 const VkImageMemoryBarrier barrier = 83 { 84 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType; 85 DE_NULL, // const void* pNext; 86 srcAccessMask, // VkAccessFlags outputMask; 87 dstAccessMask, // VkAccessFlags inputMask; 88 oldLayout, // VkImageLayout oldLayout; 89 newLayout, // VkImageLayout newLayout; 90 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex; 91 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex; 92 image, // VkImage image; 93 subresourceRange, // VkImageSubresourceRange subresourceRange; 94 }; 95 return barrier; 96 } 97 98 Move<VkCommandPool> makeCommandPool (const DeviceInterface& vk, const VkDevice device, const deUint32 queueFamilyIndex) 99 { 100 const VkCommandPoolCreateInfo info = 101 { 102 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType; 103 DE_NULL, // const void* pNext; 104 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, // VkCommandPoolCreateFlags flags; 105 queueFamilyIndex, // deUint32 queueFamilyIndex; 106 }; 107 return createCommandPool(vk, device, &info); 108 } 109 110 Move<VkCommandBuffer> makeCommandBuffer (const DeviceInterface& vk, const VkDevice device, const VkCommandPool commandPool) 111 { 112 const VkCommandBufferAllocateInfo info = 113 { 114 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType; 115 DE_NULL, // const void* pNext; 116 commandPool, // VkCommandPool commandPool; 117 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level; 118 1u, // deUint32 commandBufferCount; 119 }; 120 return allocateCommandBuffer(vk, device, &info); 121 } 122 123 Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface& vk, 124 const VkDevice device, 125 const VkDescriptorPool descriptorPool, 126 const VkDescriptorSetLayout setLayout) 127 { 128 const VkDescriptorSetAllocateInfo info = 129 { 130 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType; 131 DE_NULL, // const void* pNext; 132 descriptorPool, // VkDescriptorPool descriptorPool; 133 1u, // deUint32 descriptorSetCount; 134 &setLayout, // const VkDescriptorSetLayout* pSetLayouts; 135 }; 136 return allocateDescriptorSet(vk, device, &info); 137 } 138 139 Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface& vk, 140 const VkDevice device) 141 { 142 const VkPipelineLayoutCreateInfo info = 143 { 144 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; 145 DE_NULL, // const void* pNext; 146 (VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags; 147 0u, // deUint32 setLayoutCount; 148 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts; 149 0u, // deUint32 pushConstantRangeCount; 150 DE_NULL, // const VkPushConstantRange* pPushConstantRanges; 151 }; 152 return createPipelineLayout(vk, device, &info); 153 } 154 155 Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface& vk, 156 const VkDevice device, 157 const VkDescriptorSetLayout descriptorSetLayout) 158 { 159 const VkPipelineLayoutCreateInfo info = 160 { 161 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; 162 DE_NULL, // const void* pNext; 163 (VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags; 164 1u, // deUint32 setLayoutCount; 165 &descriptorSetLayout, // const VkDescriptorSetLayout* pSetLayouts; 166 0u, // deUint32 pushConstantRangeCount; 167 DE_NULL, // const VkPushConstantRange* pPushConstantRanges; 168 }; 169 return createPipelineLayout(vk, device, &info); 170 } 171 172 Move<VkPipeline> makeComputePipeline (const DeviceInterface& vk, 173 const VkDevice device, 174 const VkPipelineLayout pipelineLayout, 175 const VkShaderModule shaderModule, 176 const VkSpecializationInfo* specInfo) 177 { 178 const VkPipelineShaderStageCreateInfo shaderStageInfo = 179 { 180 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 181 DE_NULL, // const void* pNext; 182 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; 183 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage; 184 shaderModule, // VkShaderModule module; 185 "main", // const char* pName; 186 specInfo, // const VkSpecializationInfo* pSpecializationInfo; 187 }; 188 const VkComputePipelineCreateInfo pipelineInfo = 189 { 190 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType; 191 DE_NULL, // const void* pNext; 192 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags; 193 shaderStageInfo, // VkPipelineShaderStageCreateInfo stage; 194 pipelineLayout, // VkPipelineLayout layout; 195 DE_NULL, // VkPipeline basePipelineHandle; 196 0, // deInt32 basePipelineIndex; 197 }; 198 return createComputePipeline(vk, device, DE_NULL , &pipelineInfo); 199 } 200 201 Move<VkImageView> makeImageView (const DeviceInterface& vk, 202 const VkDevice vkDevice, 203 const VkImage image, 204 const VkImageViewType viewType, 205 const VkFormat format, 206 const VkImageSubresourceRange subresourceRange) 207 { 208 const VkImageViewCreateInfo imageViewParams = 209 { 210 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType; 211 DE_NULL, // const void* pNext; 212 (VkImageViewCreateFlags)0, // VkImageViewCreateFlags flags; 213 image, // VkImage image; 214 viewType, // VkImageViewType viewType; 215 format, // VkFormat format; 216 makeComponentMappingRGBA(), // VkComponentMapping components; 217 subresourceRange, // VkImageSubresourceRange subresourceRange; 218 }; 219 return createImageView(vk, vkDevice, &imageViewParams); 220 } 221 222 void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer) 223 { 224 const VkCommandBufferBeginInfo info = 225 { 226 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType; 227 DE_NULL, // const void* pNext; 228 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags; 229 DE_NULL, // const VkCommandBufferInheritanceInfo* pInheritanceInfo; 230 }; 231 VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info)); 232 } 233 234 void submitCommandsAndWait (const DeviceInterface& vk, 235 const VkDevice device, 236 const VkQueue queue, 237 const VkCommandBuffer commandBuffer) 238 { 239 const VkFenceCreateInfo fenceInfo = 240 { 241 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType; 242 DE_NULL, // const void* pNext; 243 (VkFenceCreateFlags)0, // VkFenceCreateFlags flags; 244 }; 245 const Unique<VkFence> fence(createFence(vk, device, &fenceInfo)); 246 247 const VkSubmitInfo submitInfo = 248 { 249 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; 250 DE_NULL, // const void* pNext; 251 0u, // uint32_t waitSemaphoreCount; 252 DE_NULL, // const VkSemaphore* pWaitSemaphores; 253 DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask; 254 1u, // uint32_t commandBufferCount; 255 &commandBuffer, // const VkCommandBuffer* pCommandBuffers; 256 0u, // uint32_t signalSemaphoreCount; 257 DE_NULL, // const VkSemaphore* pSignalSemaphores; 258 }; 259 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence)); 260 VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull)); 261 } 262 263 Move<VkFramebuffer> makeFramebuffer (const DeviceInterface& vk, 264 const VkDevice device, 265 const VkRenderPass renderPass, 266 const deUint32 attachmentCount, 267 const VkImageView* pAttachments, 268 const deUint32 width, 269 const deUint32 height, 270 const deUint32 layers) 271 { 272 const VkFramebufferCreateInfo framebufferInfo = { 273 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; 274 DE_NULL, // const void* pNext; 275 (VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags; 276 renderPass, // VkRenderPass renderPass; 277 attachmentCount, // uint32_t attachmentCount; 278 pAttachments, // const VkImageView* pAttachments; 279 width, // uint32_t width; 280 height, // uint32_t height; 281 layers, // uint32_t layers; 282 }; 283 284 return createFramebuffer(vk, device, &framebufferInfo); 285 } 286 287 MovePtr<Allocation> bindImage (const DeviceInterface& vk, const VkDevice device, Allocator& allocator, const VkImage image, const MemoryRequirement requirement) 288 { 289 MovePtr<Allocation> alloc = allocator.allocate(getImageMemoryRequirements(vk, device, image), requirement); 290 VK_CHECK(vk.bindImageMemory(device, image, alloc->getMemory(), alloc->getOffset())); 291 return alloc; 292 } 293 294 MovePtr<Allocation> bindBuffer (const DeviceInterface& vk, const VkDevice device, Allocator& allocator, const VkBuffer buffer, const MemoryRequirement requirement) 295 { 296 MovePtr<Allocation> alloc(allocator.allocate(getBufferMemoryRequirements(vk, device, buffer), requirement)); 297 VK_CHECK(vk.bindBufferMemory(device, buffer, alloc->getMemory(), alloc->getOffset())); 298 return alloc; 299 } 300 301 } // FragmentOperations 302 } // vkt 303
