Cross Reference: /external/vulkan-validation-layers/tests/layer_validation

Lines Matching full:m_device
528     ASSERT_TRUE(m_device && m_device->initialized());  // VKTriangleTest assumes Init() has finished
532     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
533     VkShaderObj ps(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
535     VkPipelineObj pipelineobj(m_device);
607     VkDescriptorSetObj descriptorSet(m_device);
614         m_depthStencil->Init(m_device, static_cast<uint32_t>(m_width), static_cast<uint32_t>(m_height), m_depth_stencil_fmt,
1303     vkQueueSubmit(m_device->m_queue, 1, &submitInfo, VK_NULL_HANDLE);
1360     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
1362     vkDestroyEvent(m_device->device(), event_handle, NULL);
1364     vkQueueWaitIdle(m_device->m_queue);
1388     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
1463     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
1488     vkCreateSampler(m_device->device(), &sampler_info, NULL, &sampler);
1505     vkCreateSampler(m_device->device(), &sampler_info, NULL, &sampler);
1526     err = vkCreateSampler(m_device->device(), &sampler_info, NULL, &sampler);
1529         vkDestroySampler(m_device->device(), sampler, NULL);
1563         err = vkCreateSampler(m_device->device(), pCreateInfo, NULL, &sampler);
1566             vkDestroySampler(m_device->device(), sampler, NULL);
1576     sampler_info.maxAnisotropy = NextAfterGreater(m_device->phy().properties().limits.maxSamplerAnisotropy);
1617     buffer.init_as_dst(*m_device, (VkDeviceSize)20, reqs);
1652     buffer.init_as_dst(*m_device, (VkDeviceSize)20, reqs);
1681     auto features = m_device->phy().features();
1747     vkCreateBuffer(m_device->device(), &buf_info, NULL, &buffer);
1770     vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
1810     result = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
1813         vkDestroyImage(m_device->device(), image, NULL);
1821     result = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
1824         vkDestroyImage(m_device->device(), image, NULL);
1832     result = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
1835         vkDestroyImage(m_device->device(), image, NULL);
1886     result = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
1889         vkDestroyImage(m_device->device(), image, NULL);
1897     result = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
1900         vkDestroyImage(m_device
1906     result = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
1909         vkDestroyImage(m_device->device(), image, NULL);
1915     result = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
1918         vkDestroyImage(m_device->device(), image, NULL);
1924     result = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
1927         vkDestroyImage(m_device->device(), image, NULL);
1956     err = vkCreateBuffer(m_device->device(), &buf_info, NULL, &buffer);
1959     vkGetBufferMemoryRequirements(m_device->device(), buffer, &buff_mem_reqs);
1981     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
1983     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image2);
1986     vkGetImageMemoryRequirements(m_device->device(), image, &img_mem_reqs);
1994     pass = m_device->phy().set_memory_type(buff_mem_reqs.memoryTypeBits & img_mem_reqs.memoryTypeBits, &alloc_info,
1997         vkDestroyBuffer(m_device->device(), buffer, NULL);
1998         vkDestroyImage(m_device->device(), image, NULL);
1999         vkDestroyImage(m_device->device(), image2, NULL);
2002     err = vkAllocateMemory(m_device->device(), &alloc_info, NULL, &mem);
2004     err = vkBindBufferMemory(m_device->device(), buffer, mem, 0);
2007     vkGetImageMemoryRequirements(m_device->device(), image2, &img_mem_reqs2);
2011     err = vkBindImageMemory(m_device->device(), image, mem, 0);
2016     err = vkCreateBuffer(m_device->device(), &buf_info, NULL, &buffer2);
2018     err = vkAllocateMemory(m_device->device(), &alloc_info, NULL, &mem_img);
2020     err = vkBindImageMemory(m_device->device(), image2, mem_img, 0);
2023     vkGetBufferMemoryRequirements(m_device->device(), buffer2, &buff_mem_reqs2);
2024     err = vkBindBufferMemory(m_device->device(), buffer2, mem_img, 0);
2027     vkDestroyBuffer(m_device->device(), buffer, NULL);
2028     vkDestroyBuffer(m_device->device(), buffer2, NULL);
2029     vkDestroyImage(m_device->device(), image, NULL);
2030     vkDestroyImage(m_device->device(), image2, NULL);
2031     vkFreeMemory(m_device->device(), mem, NULL);
2032     vkFreeMemory(m_device->device(), mem_img, NULL);
2045     const VkDeviceSize atom_size = m_device->props.limits.nonCoherentAtomSize;
2056     err = vkCreateBuffer(m_device->device(), &buf_info, NULL, &buffer);
2059     vkGetBufferMemoryRequirements(m_device->device(), buffer, &mem_reqs);
2068     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
2070         vkDestroyBuffer(m_device->device(), buffer, NULL);
2073     err = vkAllocateMemory(m_device->device(), &alloc_info, NULL, &mem);
2079     err = vkMapMemory(m_device->device(), mem, 0, 0, 0, (void **)&pData);
2082     err = vkMapMemory(m_device->device(), mem, 0, mem_reqs.size, 0, (void **)&pData);
2086     err = vkMapMemory(m_device->device(), mem, 0, mem_reqs.size, 0, (void **)&pData);
2090     vkUnmapMemory(m_device->device(), mem);
2094     err = vkMapMemory(m_device->device(), mem, allocation_size + 1, VK_WHOLE_SIZE, 0, (void **)&pData);
2098     err = vkMapMemory(m_device->device(), mem, 1, allocation_size, 0, (void **)&pData);
2102     vkUnmapMemory(m_device->device(), mem);
2106     err = vkMapMemory(m_device->device(), mem, 4 * atom_size, VK_WHOLE_SIZE, 0, (void **)&pData);
2113     vkFlushMappedMemoryRanges(m_device->device(), 1, &mmr);
2117     vkUnmapMemory(m_device->device(), mem);
2118     err = vkMapMemory(m_device->device(), mem, 0, 4 * atom_size, 0, (void **)&pData);
2123     vkFlushMappedMemoryRanges(m_device->device(), 1, &mmr);
2127     vkUnmapMemory(m_device->device(), mem);
2128     err = vkMapMemory(m_device->device(), mem, 2 * atom_size, 4 * atom_size, 0, (void **)&pData);
2133     vkFlushMappedMemoryRanges(m_device->device(), 1, &mmr);
2136     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
2139         vkFreeMemory(m_device->device(), mem, NULL);
2140         vkDestroyBuffer(m_device->device(), buffer, NULL);
2146     vkDestroyBuffer(m_device->device(), buffer, NULL);
2147     vkFreeMemory(m_device->device(), mem, NULL);
2189     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
2192     vkGetImageMemoryRequirements(m_device->device(), image, &mem_reqs);
2196     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
2199         vkDestroyImage(m_device->device(), image, NULL);
2204     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
2208     err = vkBindImageMemory(m_device->device(), image, mem, 0);
2213     err = vkMapMemory(m_device->device(), mem, 0, VK_WHOLE_SIZE, 0, &mappedAddress);
2217     vkDestroyImage(m_device->device(), image, NULL);
2218     vkFreeMemory(m_device->device(), mem, NULL);
2263     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
2266     vkGetImageMemoryRequirements(m_device->device(), image, &mem_reqs);
2269     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0);
2273     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem1);
2275     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem2);
2279     err = vkBindImageMemory(m_device->device(), image, mem1, 0);
2284     err = vkBindImageMemory(m_device
2288     vkDestroyImage(m_device->device(), image, NULL);
2289     vkFreeMemory(m_device->device(), mem1, NULL);
2290     vkFreeMemory(m_device->device(), mem2, NULL);
2312     testFence.init(*m_device, fenceInfo);
2325     vkQueueSubmit(m_device->m_queue, 1, &submit_info, testFence.handle());
2326     vkQueueWaitIdle(m_device->m_queue);
2343     VkImageObj image(m_device);
2361     vkCreateImageView(m_device->device(), &dsvci, NULL, &dsv);
2367     buffer.init_as_dst(*m_device, 128 * 128, reqs);
2402     vk_testing::QueueCreateInfoArray queue_info(m_device->queue_props);
2407     auto features = m_device->phy().features();
2442     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
2445     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool_one);
2447     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool_two);
2455     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &cb);
2457     vkFreeCommandBuffers(m_device->device(), command_pool_two, 1, &cb);
2461     vkDestroyCommandPool(m_device->device(), command_pool_one, NULL);
2462     vkDestroyCommandPool(m_device->device(), command_pool_two, NULL);
2488     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &bad_pool);
2491     OneOffDescriptorSet ds(m_device, {
2495     err = vkFreeDescriptorSets(m_device->device(), bad_pool, 1, &ds.set_);
2499     vkDestroyDescriptorPool(m_device->device(), bad_pool, NULL);
2514     vkGetImageMemoryRequirements(m_device->device(), fauxImage, &mem_reqs);
2538     auto features = m_device->phy().features();
2611     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
2614     vkGetImageMemoryRequirements(m_device->device(), image, &mem_reqs);
2630         vkDestroyImage(m_device->device(), image, NULL);
2636     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
2639     err = vkBindImageMemory(m_device->device(), image, mem, 0);
2644     vkDestroyImage(m_device->device(), image, NULL);
2645     vkFreeMemory(m_device->device(), mem, NULL);
2696         pass = m_device->phy().set_memory_type(image_mem_reqs.memoryTypeBits, &image_mem_alloc, 0);
2700 m_device->phy().set_memory_type(buffer_mem_reqs.memoryTypeBits, &buffer_mem_alloc, 0);
2722         vkDestroyImage(m_device->device(), image, NULL);
2723         vkDestroyBuffer(m_device->device(), buffer, NULL);
2742         pass = m_device->phy().set_memory_type(image_mem_reqs.memoryTypeBits, &image_alloc_info, 0);
2744         pass = m_device->phy().set_memory_type(buffer_mem_reqs.memoryTypeBits, &buffer_alloc_info, 0);
2789         pass = m_device->phy().set_memory_type(image_mem_reqs.memoryTypeBits, &image_alloc_info, 0);
2791         pass = m_device->phy().set_memory_type(buffer_mem_reqs.memoryTypeBits, &buffer_alloc_info, 0);
2880         vkGetPhysicalDeviceMemoryProperties(m_device->phy().handle(), &memory_properties);
2885             pass = m_device->phy().set_memory_type(image_unsupported_mem_type_bits, &image_alloc_info, 0);
2899             pass = m_device->phy().set_memory_type(buffer_unsupported_mem_type_bits, &buffer_alloc_info, 0);
2919         err = vkGetPhysicalDeviceImageFormatProperties(m_device->phy().handle(), sparse_image_create_info.format,
2923         if (!m_device->phy().features().sparseResidencyImage2D || err == VK_ERROR_FORMAT_NOT_SUPPORTED) {
2932                 err = vkCreateImage(m_device->device(), &sparse_image_create_info, NULL, &sparse_image);
2935                 vkGetImageMemoryRequirements(m_device->device(), sparse_image, &sparse_mem_reqs);
2942                     pass = m_device->phy().set_memory_type(sparse_mem_reqs.memoryTypeBits, &sparse_mem_alloc, 0);
2945                     err = vkAllocateMemory(m_device->device(), &sparse_mem_alloc, NULL, &sparse_mem);
2948                     err = vkBindImageMemory(m_device->device(), sparse_image, sparse_mem, 0);
2952                     vkFreeMemory(m_device->device(), sparse_mem, NULL);
2954                 vkDestroyImage(m_device->device(), sparse_image, NULL);
2963         if (!m_device->phy().features().sparseResidencyBuffer) {
2967             err = vkCreateBuffer(m_device->device(), &sparse_buffer_create_info, NULL, &sparse_buffer);
2970             vkGetBufferMemoryRequirements(m_device->device(), sparse_buffer, &sparse_mem_reqs);
2977                 pass = m_device->phy().set_memory_type(sparse_mem_reqs.memoryTypeBits, &sparse_mem_alloc, 0);
2980                 err = vkAllocateMemory(m_device->device(), &sparse_mem_alloc, NULL, &sparse_mem);
2983                 err = vkBindBufferMemory(m_device->device(), sparse_buffer, sparse_mem, 0);
2987                 vkFreeMemory(m_device->device(), sparse_mem, NULL);
2989             vkDestroyBuffer(m_device->device(), sparse_buffer, NULL);
3033     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
3036     vkGetImageMemoryRequirements(m_device->device(), image, &mem_reqs);
3039     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0);
3043     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
3047     vkDestroyImage(m_device->device(), image, NULL);
3051     err = vkBindImageMemory(m_device->device(), image, mem, 0);
3057     vkFreeMemory(m_device->device(), mem, NULL);
3095         err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mems[i]);
3103         vkFreeMemory(m_device->device(), mems[j], NULL);
3121     VkFormatProperties format_props = m_device->format_properties(input_attribs.format);
3143     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
3144     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
3146     VkPipelineObj pipe(m_device);
3154     VkDescriptorSetObj descriptorSet(m_device);
3200         VkImageObj src_image(m_device);
3205         VkImageObj dst_image(m_device);
3223         VkImageObj src_image(m_device);
3228         VkImageObj dst_image(m_device);
3254         src_buffer.init_as_src(*m_device, 128 * 128 * 4, reqs);
3257         VkImageObj dst_image(m_device);
3274         dst_buffer.init_as_dst(*m_device, 128 * 128 * 4, reqs);
3278         src_image.init(*m_device, (const VkImageCreateInfo &)image_create_info, reqs);
3318     VkImageObj unsigned_image(m_device);
3324     VkImageObj signed_image(m_device);
3330     VkImageObj float_image(m_device);
3336     VkImageObj depth_image(m_device);
3342     VkImageObj depth_image2(m_device);
3437     VkImageObj src2D(m_device);
3438     VkImageObj dst2D(m_device);
3464     VkImageObj src3D(m_device);
3525     VkImageObj img_src_transfer(m_device);
3526     VkImageObj img_dst_transfer(m_device);
3527     VkImageObj img_general(m_device);
3528     VkImageObj img_color(m_device);
3578     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
3581     err = vkQueueWaitIdle(m_device->m_queue);
3594     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
3596     err = vkQueueWaitIdle(m_device->m_queue);
3609     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
3611     err = vkQueueWaitIdle(m_device->m_queue);
3644     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
3646     err = vkQueueWaitIdle(m_device->m_queue);
3667     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
3669     err = vkQueueWaitIdle(m_device->m_queue);
3700     VkImageObj image_1D(m_device);
3706     VkImageObj image_2D(m_device);
3712     VkImageObj image_3D(m_device);
3849     VkImageObj color_img(m_device);
3855     VkImageObj ms_img(m_device);
3862     VkImageObj depth_img(m_device);
3870     VkImageObj color_3D_img(m_device);
3947     auto index = m_device->graphics_queue_node_index_;
3948     auto queue_family_properties = m_device->phy().queue_properties();
3978     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
3981     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
3991     vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
3993     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
3995     err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
3998     vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
4000     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
4002     err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
4005     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
4007     err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
4046     buffer.init_as_dst(*m_device, 128 * 128, reqs);
4096     vkDestroyImage(m_device->device(), srcImage, NULL);
4097     vkDestroyImage(m_device->device(), dstImage, NULL);
4098     vkFreeMemory(m_device->device(), srcMem, NULL);
4099     vkFreeMemory(m_device->device(), destMem, NULL);
4110     auto queue_family_properties = m_device->phy().queue_properties();
4124     vkGetDeviceQueue(m_device->device(), other_queue_family, 0, &other_queue);
4126     VkCommandPoolObj cmd_pool(m_device, queue_family);
4127     VkCommandBufferObj cmd_buff(m_device, &cmd_pool);
4157     vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
4185     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
4188     VkImageObj image(m_device);
4194     err = vkCreateFramebuffer(m_device->device(), &fbci, nullptr, &fb);
4205     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
4206     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
4207     VkPipelineObj pipe(m_device);
4218     const VkPipelineLayoutObj pl(m_device);
4257     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
4258     vkDestroyRenderPass(m_device->device(), rp, nullptr);
4286     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
4290     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp_noselfdep);
4293     VkImageObj image(m_device);
4299     err = vkCreateFramebuffer(m_device->device(), &fbci, nullptr, &fb);
4405     buffer.init_as_src_and_dst(*m_device, 256, mem_reqs);
4421     VkImageObj lone_image(m_device);
4447     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
4448     vkDestroyRenderPass(m_device->device(), rp, nullptr);
4449     vkDestroyRenderPass(m_device->device(), rp_noselfdep, nullptr);
4476     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
4479     VkImageObj image(m_device);
4483     VkImageObj image2(m_device);
4488     err = vkCreateFramebuffer(m_device->device(), &fbci, nullptr, &fb);
4507     VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
4508     VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
4544     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
4545     vkDestroyRenderPass(m_device->device(), rp, nullptr);
4577     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
4580     VkImageObj image(m_device);
4583     VkImageObj image2(m_device);
4591     err = vkCreateFramebuffer(m_device->device(), &fbci, nullptr, &fb);
4628     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
4629     vkDestroyRenderPass(m_device->device(), rp, nullptr);
4682     err = vkCreateSemaphore(m_device->device(), &sci, nullptr, &export_semaphore);
4688     err = vkCreateSemaphore(m_device->device(), &sci, nullptr, &import_semaphore);
4697         (PFN_vkGetSemaphoreWin32HandleKHR)vkGetDeviceProcAddr(m_device->device(), "vkGetSemaphoreWin32HandleKHR");
4698     err = vkGetSemaphoreWin32HandleKHR(m_device->device(), &ghi, &handle);
4710         (PFN_vkImportSemaphoreWin32HandleKHR)vkGetDeviceProcAddr(m_device->device(), "vkImportSemaphoreWin32HandleKHR");
4711     err = vkImportSemaphoreWin32HandleKHR(m_device->device(), &ihi);
4717     auto vkGetSemaphoreFdKHR = (PFN_vkGetSemaphoreFdKHR)vkGetDeviceProcAddr(m_device->device(), "vkGetSemaphoreFdKHR");
4718     err = vkGetSemaphoreFdKHR(m_device->device(), &ghi, &fd);
4724     auto vkImportSemaphoreFdKHR = (PFN_vkImportSemaphoreFdKHR)vkGetDeviceProcAddr(m_device->device(), "vkImportSemaphoreFdKHR");
4725     err = vkImportSemaphoreFdKHR(m_device->device(), &ihi);
4738     vkQueueSubmit(m_device->m_queue, 4, si, VK_NULL_HANDLE);
4749     vkQueueBindSparse(m_device->m_queue, 4, bi, VK_NULL_HANDLE);
4753     err = vkQueueWaitIdle(m_device->m_queue);
4755     vkDestroySemaphore(m_device->device(), export_semaphore, nullptr);
4756     vkDestroySemaphore(m_device->device(), import_semaphore, nullptr);
4807         err = vkCreateFence(m_device->device(), &fci, nullptr, &export_fence);
4815         err = vkCreateFence(m_device->device(), &fci, nullptr, &import_fence);
4825             (PFN_vkGetFenceWin32HandleKHR)vkGetDeviceProcAddr(m_device->device(), "vkGetFenceWin32HandleKHR");
4826         err = vkGetFenceWin32HandleKHR(m_device->device(), &ghi, &handle);
4840             (PFN_vkImportFenceWin32HandleKHR)vkGetDeviceProcAddr(m_device->device(), "vkImportFenceWin32HandleKHR");
4841         err = vkImportFenceWin32HandleKHR(m_device->device(), &ifi);
4849         auto vkGetFenceFdKHR = (PFN_vkGetFenceFdKHR)vkGetDeviceProcAddr(m_device->device(), "vkGetFenceFdKHR");
4850         err = vkGetFenceFdKHR(m_device->device(), &gfi, &fd);
4858         auto vkImportFenceFdKHR = (PFN_vkImportFenceFdKHR)vkGetDeviceProcAddr(m_device->device(), "vkImportFenceFdKHR");
4859         err = vkImportFenceFdKHR(m_device->device(), &ifi);
4865     vkResetFences(m_device->device(), 1, &import_fence);
4868     vkQueueSubmit(m_device->m_queue, 0, nullptr, import_fence);
4870     vkQueueSubmit(m_device->m_queue, 0, nullptr, import_fence);
4874     err = vkQueueWaitIdle(m_device->m_queue);
4876     vkDestroyFence(m_device->device(), export_fence, nullptr);
4877     vkDestroyFence(m_device->device(), import_fence, nullptr);
4904     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
4907     VkImageObj image(m_device);
4913     err = vkCreateFramebuffer(m_device->device(), &fbci, nullptr, &fb);
4932     VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
4933     VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
4980     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
4981     vkQueueWaitIdle(m_device->m_queue);
4983     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
4984     vkDestroyRenderPass(m_device->device(), rp, nullptr);
5015     VkDescriptorSetObj descriptorSet(m_device);
5019     VkPipelineObj pipeline(m_device);
5049     vkCreateRenderPass(m_device->device(), &rpci, NULL, &renderpass);
5050     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
5062     vkDestroyRenderPass(m_device->device(), renderpass, NULL);
5071     VkDescriptorSetObj ds_obj(m_device);
5075     VkShaderObj vs_obj(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
5081     VkRenderpassObj rp_obj(m_device);
5085         VkPipelineObj pipeline(m_device);
5169         std::vector<VkAttachmentReference> too_many_colors(m_device->props.limits.maxColorAttachments + 1, color[0]);
5174         err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
5176         if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5184     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
5186     if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5191     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
5193     if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5198     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
5200     if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5206     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
5208     if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5214     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
5216     if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5221     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
5223     if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5228     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
5230     if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5235     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
5237     if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5243 m_device->device(), &rpci, nullptr, &rp);
5245     if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5252     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
5254     if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5273         err = vkCreateRenderPass(m_device->device(), &rpci_multipass, nullptr, &rp);
5275         if (err == VK_SUCCESS) vkDestroyRenderPass(m_device->device(), rp, nullptr);
5314     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
5336         vkDestroyFramebuffer(m_device->device(), fb, NULL);
5338     vkDestroyRenderPass(m_device->device(), rp, NULL);
5346     err = vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp_ds);
5357         vkDestroyFramebuffer(m_device->device(), fb, NULL);
5359     vkDestroyRenderPass(m_device->device(), rp_ds, NULL);
5365     err = vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
5376         vkDestroyFramebuffer(m_device->device(), fb, NULL);
5378     vkDestroyRenderPass(m_device->device(), rp, NULL);
5383     err = vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
5393         vkDestroyFramebuffer(m_device->device(), fb, NULL);
5396     vkDestroyRenderPass(m_device->device(), rp, NULL);
5400         VkImageObj image(m_device);
5416         err = vkCreateImageView(m_device->device(), &ivci, NULL, &view);
5421         err = vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
5431             vkDestroyFramebuffer(m_device->device(), fb, NULL);
5433         vkDestroyImageView(m_device->device(), view, NULL);
5446         vkDestroyFramebuffer(m_device->device(), fb, NULL);
5451         VkImageObj image(m_device);
5470         err = vkCreateImageView(m_device->device(), &ivci, NULL, &view);
5483             vkDestroyFramebuffer(m_device->device(), fb, NULL);
5485         vkDestroyImageView(m_device->device(), view, NULL);
5492     fb_info.width = m_device->props.limits.maxFramebufferWidth + 1;
5500         vkDestroyFramebuffer(m_device->device(), fb, NULL);
5508         vkDestroyFramebuffer(m_device->device(), fb, NULL);
5513     fb_info.height = m_device->props.limits.maxFramebufferHeight + 1;
5520         vkDestroyFramebuffer(m_device->device(), fb, NULL);
5528         vkDestroyFramebuffer(m_device->device(), fb, NULL);
5534     fb_info.layers = m_device->props.limits.maxFramebufferLayers + 1;
5540         vkDestroyFramebuffer(m_device->device(), fb, NULL);
5548         vkDestroyFramebuffer(m_device->device(), fb, NULL);
5551     vkDestroyRenderPass(m_device->device(), rp, NULL);
5616     if (!m_device->phy().features().depthBounds) {
5700     err = vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
5702     vkQueueWaitIdle(m_device->m_queue);
5706     err = vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
5707     vkQueueWaitIdle(m_device->m_queue);
5734     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
5744     const VkDescriptorSetLayoutObj ds_layout_samp(m_device, {dsl_binding_samp});
5755     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, descriptor_sets);
5767     const VkDescriptorSetLayoutObj ds_layout_ub(m_device, {dsl_binding});
5773     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptor_set);
5777     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
5803     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
5813     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
5821     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
5824     err = vkFreeDescriptorSets(m_device->device(), ds_pool, 1, &descriptorSet);
5827     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
5862     const VkDescriptorSetLayoutObj descriptor_set_layout(m_device, {layout_binding});
5919     VkResult err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
5939     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
5950     const VkDescriptorSetLayoutObj ds_layout(m_device, layout_bindings);
5958     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
5969     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
5982     err = vkCreateBuffer(m_device->device(), &buffCI, NULL, &dyub);
5987     vkGetBufferMemoryRequirements(m_device->device(), dyub, &mem_reqs);
5992     m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
5993     err = vkAllocateMemory(m_device->device(), &mem_alloc_info, NULL, &mem);
5996     err = vkBindBufferMemory(m_device->device(), dyub, mem, 0);
6011     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
6024     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
6027     vkDestroyBuffer(m_device->device(), dyub, NULL);
6028     vkFreeMemory(m_device->device(), mem, NULL);
6029     vkDestroySampler(m_device->device(), sampler, NULL);
6030     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
6042     OneOffDescriptorSet ds(m_device, {
6047     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
6057     buffer0.init(*m_device, bci);
6058     VkPipelineObj pipe(m_device);
6062         buffer1.init(*m_device, bci);
6084         vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
6102         VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
6103         VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
6134     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
6155     VkResult err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6159     const auto excess_layouts = 1 + m_device->phy().properties().limits.maxBoundDescriptorSets;
6170     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6174     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6182     uint32_t max_uniform_buffers = m_device->phy().properties().limits.maxPerStageDescriptorUniformBuffers;
6183     uint32_t max_storage_buffers = m_device->phy().properties().limits.maxPerStageDescriptorStorageBuffers;
6184     uint32_t max_sampled_images = m_device->phy().properties().limits.maxPerStageDescriptorSampledImages;
6185     uint32_t max_storage_images = m_device->phy().properties().limits.maxPerStageDescriptorStorageImages;
6186     uint32_t max_samplers = m_device->phy().properties().limits.maxPerStageDescriptorSamplers;
6188     uint32_t max_input_attachments = m_device->phy().properties().limits.maxPerStageDescriptorInputAttachments;
6190     uint32_t sum_dyn_uniform_buffers = m_device->phy().properties().limits.maxDescriptorSetUniformBuffersDynamic;
6191     uint32_t sum_uniform_buffers = m_device->phy().properties().limits.maxDescriptorSetUniformBuffers;
6192     uint32_t sum_dyn_storage_buffers = m_device->phy().properties().limits.maxDescriptorSetStorageBuffersDynamic;
6193     uint32_t sum_storage_buffers = m_device->phy().properties().limits.maxDescriptorSetStorageBuffers;
6194     uint32_t sum_sampled_images = m_device->phy().properties().limits.maxDescriptorSetSampledImages;
6195     uint32_t sum_storage_images = m_device->phy().properties().limits.maxDescriptorSetStorageImages;
6196     uint32_t sum_samplers = m_device->phy().properties().limits.maxDescriptorSetSamplers;
6197     uint32_t sum_input_attachments = m_device->phy().properties().limits.maxDescriptorSetInputAttachments;
6200     gfx_stages += (m_device->phy().features().geometryShader ? 1 : 0);
6201     gfx_stages += (m_device->phy().features().tessellationShader ? 2 : 0);
6238     VkResult err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6250     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6252     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6254     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6270     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6282     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6284     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6286     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6305     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6317     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6319     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6321     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6341     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6353     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6355     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6357     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6373     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6381     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6383     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6385     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6397     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6405     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6407     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6409     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6417     uint32_t max_uniform_buffers = m_device->phy().properties().limits.maxPerStageDescriptorUniformBuffers;
6418     uint32_t max_storage_buffers = m_device->phy().properties().limits.maxPerStageDescriptorStorageBuffers;
6419     uint32_t max_sampled_images = m_device->phy().properties().limits.maxPerStageDescriptorSampledImages;
6420     uint32_t max_storage_images = m_device->phy().properties().limits.maxPerStageDescriptorStorageImages;
6421     uint32_t max_samplers = m_device->phy().properties().limits.maxPerStageDescriptorSamplers;
6422     uint32_t max_input_attachments = m_device->phy().properties().limits.maxPerStageDescriptorInputAttachments;
6424     uint32_t sum_dyn_uniform_buffers = m_device->phy().properties().limits.maxDescriptorSetUniformBuffersDynamic;
6425     uint32_t sum_uniform_buffers = m_device->phy().properties().limits.maxDescriptorSetUniformBuffers;
6426     uint32_t sum_dyn_storage_buffers = m_device->phy().properties().limits.maxDescriptorSetStorageBuffersDynamic;
6427     uint32_t sum_storage_buffers = m_device->phy().properties().limits.maxDescriptorSetStorageBuffers;
6428     uint32_t sum_sampled_images = m_device->phy().properties().limits.maxDescriptorSetSampledImages;
6429     uint32_t sum_storage_images = m_device->phy().properties().limits.maxDescriptorSetStorageImages;
6430     uint32_t sum_samplers = m_device->phy().properties().limits.maxDescriptorSetSamplers;
6431     uint32_t sum_input_attachments = m_device->phy().properties().limits.maxDescriptorSetInputAttachments;
6468     VkResult err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6476     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6478     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6480     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6493     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6501     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6503     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6505     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6518     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6526     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6528     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6530     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6543     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6551     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6553     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6555     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6568     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6576     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6578     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6580     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6603     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6611     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6613     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6615     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6632     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6640     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6642     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6644     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6657     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
6665     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
6667     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);  // Unnecessary but harmless if test passed
6669     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
6685     VkResult err = vkCreateBuffer(m_device->device(), &buf_info, NULL, &buffer);
6688     vkGetBufferMemoryRequirements(m_device->device(), buffer, &mem_reqs);
6694     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
6696         vkDestroyBuffer(m_device->device(), buffer, NULL);
6699     err = vkAllocateMemory(m_device->device(), &alloc_info, NULL, &mem);
6702     err = vkBindBufferMemory(m_device->device(), buffer, mem, 0);
6711     vkDestroyBuffer(m_device->device(), buffer, NULL);
6717     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
6720     vkQueueWaitIdle(m_device->m_queue);
6721     vkFreeMemory(m_device->handle(), mem, NULL);
6741     VkResult err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
6751     const VkDescriptorSetLayoutObj ds_layout(m_device, {layout_binding});
6759     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptor_set);
6762     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds_layout});
6773     err = vkCreateBuffer(m_device->device(), &buffer_create_info, NULL, &buffer);
6784     vkGetBufferMemoryRequirements(m_device->device(), buffer, &memory_reqs);
6786     bool pass = m_device->phy().set_memory_type(memory_reqs.memoryTypeBits, &memory_info, 0);
6789     err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &buffer_memory);
6791     err = vkBindBufferMemory(m_device->device(), buffer, buffer_memory, 0);
6801     err = vkCreateBufferView(m_device->device(), &bvci, NULL, &view);
6812     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
6828     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
6829     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
6830     VkPipelineObj pipe(m_device);
6854     vkDestroyBufferView(m_device->device(), view, NULL);
6860     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
6864     vkDestroyBuffer(m_device->device(), buffer, NULL);
6865     vkFreeMemory(m_device->device(), buffer_memory, NULL);
6866     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
6889     VkResult err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
6899     vkGetImageMemoryRequirements(m_device->device(), image, &mem_reqs);
6901     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0);
6903     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &image_mem);
6905     err = vkBindImageMemory(m_device->device(), image, image_mem, 0);
6925     vkDestroyImage(m_device->device(), image, NULL);
6931     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
6934     vkFreeMemory(m_device->device(), image_mem, nullptr);
6966     ASSERT_VK_SUCCESS(vkCreateImage(m_device->handle(), &image_ci, NULL, &image));
6976     vkGetImageMemoryRequirements(m_device->device(), image, &memory_reqs);
6978     pass = m_device->phy().set_memory_type(memory_reqs.memoryTypeBits, &memory_info, 0);
6980     err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &image_memory);
6982     err = vkBindImageMemory(m_device->device(), image, image_memory, 0);
6996     err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
7001     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
7014     vkDestroyImage(m_device->device(), image, NULL);
7020     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
7021     vkDestroyImageView(m_device->device(), view, nullptr);
7022     vkFreeMemory(m_device->device(), image_memory, nullptr);
7034     VkImageObj image(m_device);
7041     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
7056     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7059     vkDestroyFramebuffer(m_device->device(), fb, NULL);
7062     vkQueueWaitIdle(m_device->m_queue);
7065     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
7093     ASSERT_VK_SUCCESS(vkCreateImage(m_device->handle(), &image_ci, NULL, &image));
7103     vkGetImageMemoryRequirements(m_device->device(), image, &memory_reqs);
7105     pass = m_device->phy().set_memory_type(memory_reqs.memoryTypeBits, &memory_info, 0);
7107     err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &image_memory);
7109     err = vkBindImageMemory(m_device->device(), image, image_memory, 0);
7123     err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
7128     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
7144     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7147     vkDestroyImage(m_device->device(), image, NULL);
7150     vkQueueWaitIdle(m_device->m_queue);
7153     vkDestroyImage(m_device->device(), image, NULL);
7154     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
7155     vkDestroyImageView(m_device->device(), view, nullptr);
7156     vkFreeMemory(m_device->device(), image_memory, nullptr);
7182     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
7200     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7204     vkDestroyRenderPass(m_device->device(), rp, nullptr);
7208     vkQueueWaitIdle(m_device->m_queue);
7211     vkDestroyRenderPass(m_device->device(), rp, nullptr);
7234     VkResult err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
7244     vkGetImageMemoryRequirements(m_device->device(), image, &mem_reqs);
7246     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0);
7248     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &image_mem);
7251     // Introduce error, do not call vkBindImageMemory(m_device->device(), image, image_mem, 0);
7271     vkDestroyImage(m_device->device(), image, NULL);
7272     vkFreeMemory(m_device->device(), image_mem, nullptr);
7279     VkImageObj image(m_device);
7293     VkResult err = vkCreateBuffer(m_device->device(), &buf_info, NULL, &buffer);
7296     vkGetBufferMemoryRequirements(m_device->device(), buffer, &mem_reqs);
7302     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
7304         vkDestroyBuffer(m_device->device(), buffer, NULL);
7307     err = vkAllocateMemory(m_device->device(), &alloc_info, NULL, &mem);
7310     // Introduce failure by not calling vkBindBufferMemory(m_device->device(), buffer, mem, 0);
7328     vkDestroyBuffer(m_device->device(), buffer, NULL);
7329     vkFreeMemory(m_device->handle(), mem, NULL);
7339     VkResult result = vkCreateEvent(m_device->device(), &evci, NULL, &event);
7348     vkDestroyEvent(m_device->device(), event, NULL);
7354     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7368     VkResult result = vkCreateQueryPool(m_device->device(), &qpci, nullptr, &query_pool);
7377     vkDestroyQueryPool(m_device->device(), query_pool, NULL);
7383     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7465     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
7466     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
7468     VkPipelineObj pipe(m_device);
7479     const VkPipelineLayoutObj pl(m_device);
7488     vkDestroyRenderPass(m_device->device(), rp, nullptr);
7497     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7499     vkQueueWaitIdle(m_device->m_queue);
7522     VkResult err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
7532     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
7540     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
7543     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds_layout});
7555     err = vkCreateBuffer(m_device->device(), &buffCI, NULL, &buffer);
7560     vkGetBufferMemoryRequirements(m_device->device(), buffer, &memReqs);
7566     bool pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &mem_alloc, 0);
7568         vkDestroyBuffer(m_device->device(), buffer, NULL);
7573     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
7575     err = vkBindBufferMemory(m_device->device(), buffer, mem, 0);
7592     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
7609     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
7610     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
7611     VkPipelineObj pipe(m_device);
7631     vkDestroyBuffer(m_device->device(), buffer, NULL);
7637     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7640     vkFreeMemory(m_device->device(), mem, NULL);
7642     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
7667     VkResult err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
7677     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
7685     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
7688     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds_layout});
7710     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
7712     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image2);
7723     vkGetImageMemoryRequirements(m_device->device(), image, &memory_reqs);
7726     pass = m_device->phy().set_memory_type(memory_reqs.memoryTypeBits, &memory_info, 0);
7728     err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &image_memory);
7730     err = vkBindImageMemory(m_device->device(), image, image_memory, 0);
7733     err = vkBindImageMemory(m_device->device(), image2, image_memory, memory_reqs.size);
7749     err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &tmp_view);
7751     err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
7754     err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view2);
7760     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
7762     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler2);
7779     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
7796     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
7797     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
7798     VkPipelineObj pipe(m_device);
7822     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7823     vkQueueWaitIdle(m_device->m_queue);
7826     vkDestroyImageView(m_device->device(), tmp_view, NULL);
7842     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
7855     vkDestroySampler(m_device->device(), sampler, NULL);
7862     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7867     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
7885     vkDestroyImage(m_device->device(), image, NULL);
7891     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7895     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
7906     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7910     vkFreeDescriptorSets(m_device->device(), ds_pool, 1, &descriptorSet);
7915     vkQueueWaitIdle(m_device->m_queue);
7920     vkFreeDescriptorSets(m_device->device(), ds_pool, 1, &descriptorSet);
7928     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7932     vkFreeMemory(m_device->device(), image_memory, NULL);
7933     vkDestroySampler(m_device->device(), sampler2, NULL);
7934     vkDestroyImage(m_device->device(), image2, NULL);
7935     vkDestroyImageView(m_device->device(), view, NULL);
7936     vkDestroyImageView(m_device->device(), view2, NULL);
7937     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
7959     VkResult err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
7969     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
7977     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
7980     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds_layout});
7984     VkImageObj image(m_device);
8000     err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
8005     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
8023     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
8040     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
8041     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
8042     VkPipelineObj pipe(m_device);
8048     VkCommandBufferObj cmd_buf(m_device, m_commandPool);
8076     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
8077     vkQueueWaitIdle(m_device->m_queue);
8079     vkDestroySampler(m_device->device(), sampler, NULL);
8080     vkDestroyImageView(m_device->device(), view, NULL);
8081     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
8102     VkResult err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
8112     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
8120     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptor_set);
8123     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds_layout});
8126     VkImageObj image(m_device);
8134     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
8151     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
8168     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
8169     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
8170     VkPipelineObj pipe(m_device);
8195     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
8198     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
8200     vkQueueWaitIdle(m_device->m_queue);
8202     vkDestroySampler(m_device->device(), sampler, NULL);
8206     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
8228     VkResult err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
8238     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
8246     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
8249     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds_layout});
8270     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
8281     vkGetImageMemoryRequirements(m_device->device(), image, &memory_reqs);
8284     pass = m_device->phy().set_memory_type(memory_reqs.memoryTypeBits, &memory_info, 0);
8286     err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &image_memory);
8288     err = vkBindImageMemory(m_device->device(), image, image_memory, 0);
8302     err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
8307     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
8324     vkFreeMemory(m_device->device(), image_memory, nullptr);
8329     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
8332     vkDestroyImage(m_device->device(), image, NULL);
8333     vkDestroySampler(m_device->device(), sampler, NULL);
8334     vkDestroyImageView(m_device->device(), view, NULL);
8335     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
8381     uint32_t x_limit = m_device->props.limits.maxComputeWorkGroupCount[0];
8382     uint32_t y_limit = m_device->props.limits.maxComputeWorkGroupCount[1];
8383     uint32_t z_limit = m_device->props.limits.maxComputeWorkGroupCount[2];
8391     VkShaderObj cs_obj(m_device, cs_text.c_str(), VK_SHADER_STAGE_COMPUTE_BIT, this);
8674     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
8684     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
8692     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
8695     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds_layout});
8697     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
8700     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
8702     VkPipelineObj pipe(m_device);
8715     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
8739     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
8749     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
8757     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
8770     err = vkCreateBuffer(m_device->device(), &buffer_create_info, NULL, &buffer);
8781     vkGetBufferMemoryRequirements(m_device->device(), buffer, &memory_reqs);
8783     bool pass = m_device->phy().set_memory_type(memory_reqs.memoryTypeBits, &memory_info, 0);
8786     err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &buffer_memory);
8788     err = vkBindBufferMemory(m_device->device(), buffer, buffer_memory, 0);
8798     err = vkCreateBufferView(m_device->device(), &bvci, NULL, &view);
8802     vkDestroyBuffer(m_device->device(), buffer, NULL);
8813     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
8817     vkDestroyBufferView(m_device->device(), view, NULL);
8819     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
8822     vkFreeMemory(m_device->device(), buffer_memory, NULL);
8823     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
8843     err = vkCreateBuffer(m_device->device(), &buff_ci, NULL, &buffer);
8852     err = vkCreateBufferView(m_device->device(), &buff_view_ci, NULL, &buff_view);
8855     vkDestroyBuffer(m_device->device(), buffer, NULL);
8858         vkDestroyBufferView(m_device->device(), buff_view, NULL);
8888     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
8898     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
8906     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
8909     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds_layout});
8921     err = vkCreateBuffer(m_device->device(), &buffCI, NULL, &dyub);
8925     vkGetBufferMemoryRequirements(m_device->device(), dyub, &memReqs);
8931     bool pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &mem_alloc, 0);
8933         vkDestroyBuffer(m_device->device(), dyub, NULL);
8938     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
8940     err = vkBindBufferMemory(m_device->device(), dyub, mem, 0);
8957     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
8990     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
8991     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
8992     VkPipelineObj pipe(m_device);
9011     vkDestroyBuffer(m_device->device(), dyub, NULL);
9012     vkFreeMemory(m_device->device(), mem, NULL);
9014     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
9041     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
9051     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
9059     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
9072     err = vkCreateBuffer(m_device->device(), &buffCI, NULL, &dyub);
9090     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
9093     vkDestroyBuffer(m_device->device(), dyub, NULL);
9094     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
9117     const uint32_t too_big = m_device->props.limits.maxPushConstantsSize + 0x4;
9137         vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
9148     vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
9205         vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
9216 m_device, {}, pc_range2);
9287     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
9310     ds_layouts.emplace_back(m_device, std::vector<VkDescriptorSetLayoutBinding>(1, dsl_binding[0]));
9312     const VkDescriptorSetLayoutObj ds_layout_fs_only(m_device, {dsl_fs_stage_only});
9322     ds_layouts.emplace_back(m_device, std::vector<VkDescriptorSetLayoutBinding>({dsl_binding[0], dsl_binding[1]}));
9327     ds_layouts.emplace_back(m_device, std::vector<VkDescriptorSetLayoutBinding>(1, dsl_binding[0]));
9331     ds_layouts.emplace_back(m_device, std::vector<VkDescriptorSetLayoutBinding>(1, dsl_binding[0]));
9342     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, descriptorSet);
9347     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &ds0_fs_only);
9350     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds_layouts[0], &ds_layouts[1]});
9352     const VkPipelineLayoutObj single_pipe_layout(m_device, {&ds_layouts[0]});
9354     const VkPipelineLayoutObj pipe_layout_one_desc(m_device, {&ds_layouts[3]});
9356     const VkPipelineLayoutObj pipe_layout_five_samp(m_device, {&ds_layouts[2]});
9358     VkPipelineLayoutObj pipe_layout_fs_only(m_device, {&ds_layout_fs_only});
9360     const VkPipelineLayoutObj pipe_layout_bad_set0(m_device, {&ds_layout_fs_only, &ds_layouts[1]});
9377     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
9378     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
9379     VkPipelineObj pipe(m_device);
9463     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
9471     VkCommandBufferObj commandBuffer(m_device, m_commandPool);
9481     VkCommandBufferObj cb(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9504     VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
9505     VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9528     VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
9529     VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9550     vkCreateEvent(m_device->device(), &eci, nullptr, &event);
9552     VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9562     vkDestroyEvent(m_device->device(), event, nullptr);
9579     VkCommandBufferObj commandBuffer(m_device, m_commandPool);
9632     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
9642     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
9650     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
9653     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds_layout});
9680     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
9681     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
9706     err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
9708     err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
9711     vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
9712     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
9817     err = vkCreateDescriptorPool(m_device->device(),
9836     err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL,
9841     err = vkAllocateDescriptorSets(m_device->device(), ds_pool,
9853     err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL,
9860     VkShaderObj vs(m_device,bindStateVertShaderText,VK_SHADER_STAGE_VERTEX_BIT,
9864 tc(m_device,bindStateVertShaderText,VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
9867 te(m_device,bindStateVertShaderText,VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
9919     err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL,
9922     err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1,
9927     vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
9928     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
9929     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
9930     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
10068     if (!m_device->phy().features().multiViewport) {
10101     const auto max_viewports = m_device->phy().properties().limits.maxViewports;
10181     if (!m_device->phy().features().multiViewport) {
10189     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
10190     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
10192     const VkPipelineLayoutObj pipeline_layout(m_device);
10194     VkPipelineObj pipeline_dyn_vp(m_device);
10202     VkPipelineObj pipeline_dyn_sc(m_device);
10235     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
10236     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
10271     const VkPipelineLayoutObj pipeline_layout(m_device);
10295         vkCreateGraphicsPipelines(m_device->device(), VK_NULL_HANDLE, 1, &gp_ci, nullptr, &pipeline);
10320         VkResult err = vkCreatePipelineCache(m_device->device(), &create_info, nullptr, &pipeline_cache);
10324     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
10325     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
10333     vertex_input_binding_description.binding = m_device->props.limits.maxVertexInputBindings;
10374     const VkPipelineLayoutObj pipeline_layout(m_device);
10392         vkCreateGraphicsPipelines(m_device->device(), pipeline_cache, 1, &create_info, nullptr, &pipeline);
10396     vkDestroyPipelineCache(m_device->device(), pipeline_cache, nullptr);
10411         VkResult err = vkCreatePipelineCache(m_device->device(), &create_info, nullptr, &pipeline_cache);
10415     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
10416     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
10424     vertex_input_binding_description.stride = m_device->props.limits.maxVertexInputBindingStride + 1;
10465     const VkPipelineLayoutObj pipeline_layout(m_device);
10483         vkCreateGraphicsPipelines(m_device->device(), pipeline_cache, 1, &create_info, nullptr, &pipeline);
10487     vkDestroyPipelineCache(m_device->device(), pipeline_cache, nullptr);
10501         VkResult err = vkCreatePipelineCache(m_device->device(), &create_info, nullptr, &pipeline_cache);
10505     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
10506     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
10514     vertex_input_attribute_description.location = m_device->props.limits.maxVertexInputAttributes;
10555     const VkPipelineLayoutObj pipeline_layout(m_device);
10573         vkCreateGraphicsPipelines(m_device->device(), pipeline_cache, 1, &create_info, nullptr, &pipeline);
10577     vkDestroyPipelineCache(m_device->device(), pipeline_cache, nullptr);
10591         VkResult err = vkCreatePipelineCache(m_device->device(), &create_info, nullptr, &pipeline_cache);
10595     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
10596     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
10604     vertex_input_attribute_description.binding = m_device->props.limits.maxVertexInputBindings;
10645     const VkPipelineLayoutObj pipeline_layout(m_device);
10663         vkCreateGraphicsPipelines(m_device->device(), pipeline_cache, 1, &create_info, nullptr, &pipeline);
10667     vkDestroyPipelineCache(m_device->device(), pipeline_cache, nullptr);
10705         VkResult err = vkCreatePipelineCache(m_device->device(), &create_info, nullptr, &pipeline_cache);
10709     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
10710     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
10718     vertex_input_binding_description.stride = m_device->props.limits.maxVertexInputBindingStride;
10755     const VkPipelineLayoutObj pipeline_layout(m_device);
10773         vkCreateGraphicsPipelines(m_device->device(), pipeline_cache, 1, &create_info, nullptr, &pipeline);
10777     vkDestroyPipelineCache(m_device->device(), pipeline_cache, nullptr);
10840     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
10869     vkDestroyRenderPass(m_device->device(), rp, NULL);
10904     dstBuffer.init_as_dst(*m_device, (VkDeviceSize)1024, reqs);
10924     dstBuffer.init_as_dst(*m_device, (VkDeviceSize)1024, reqs);
10940     VkImageObj image(m_device);
11030     VkImageObj image(m_device);
11141     dstImage.init(*m_device, (const VkImageCreateInfo &)image_create_info, reqs);
11176     dst_image_bad_usage.init(*m_device, (const VkImageCreateInfo &)image_create_info, reqs);
11188     dst_image.init(*m_device, (const VkImageCreateInfo &)image_create_info, reqs);
11255     VkResult err = vkCreateRenderPass(m_device->device(), &rcpi, nullptr, &rp);
11261     err = vkCreateFramebuffer(m_device->device(), &fbci, nullptr, &fb);
11275     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
11276     vkDestroyRenderPass(m_device->device(), rp, nullptr);
11316     VkImageObj image(m_device);
11355     buffer.init_as_src_and_dst(*m_device, 256, mem_reqs);
11388     VkDepthStencilObj ds_image(m_device);
11389     ds_image.Init(m_device, 128, 128, depth_format);
11420     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D16_UNORM, &format_props);
11422         VkDepthStencilObj d_image(m_device);
11423         d_image.Init(m_device, 128, 128, VK_FORMAT_D16_UNORM);
11449     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_S8_UINT, &format_props);
11451         VkDepthStencilObj s_image(m_device);
11452         s_image.Init(m_device, 128, 128, VK_FORMAT_S8_UINT);
11468     VkImageObj c_image(m_device);
11495         VkImageObj img_color(m_device);
11499         VkImageObj img_ds(m_device);
11503         VkImageObj img_xfer_src(m_device);
11507         VkImageObj img_xfer_dst(m_device);
11511         VkImageObj img_sampled(m_device);
11515         VkImageObj img_input(m_device);
11609     const std::vector<VkQueueFamilyProperties> queue_props = m_device->queue_props;
11610     uint32_t queue_family_index = m_device->QueueFamilyWithoutCapabilities(VK_QUEUE_COMPUTE_BIT);
11617     VkCommandPoolObj command_pool(m_device, queue_family_index, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
11618     VkCommandBufferObj bad_command_buffer(m_device, &command_pool);
11636     vkCreateEvent(m_device->device(), &event_create_info, nullptr, &event);
11710     const uint32_t submit_family = m_device->graphics_queue_node_index_;
11711     const uint32_t invalid = static_cast<uint32_t>(m_device->queue_props.size());
11743         excl_test(VALIDATION_ERROR_0a00096a, VALIDATION_ERROR_01800958, other_family, other_family, false, m_device->m_queue);
11747         excl_test(VALIDATION_ERROR_0a00096a, VALIDATION_ERROR_01800958, submit_family, other_family, true, m_device->m_queue);
11748         excl_test(VALIDATION_ERROR_0a00096a, VALIDATION_ERROR_01800958, other_family, submit_family, true, m_device->m_queue);
11766     const uint32_t submit_family = m_device->graphics_queue_node_index_;
11767     const uint32_t invalid = static_cast<uint32_t>(m_device->queue_props.size());
11828     VkImageObj image(m_device);
11952         VkResult err = vkCreateEvent(m_device->handle(), &eci, nullptr, &event);
12045         vkDestroyEvent(m_device->handle(), event, nullptr);
12062         (PFN_vkCreateValidationCacheEXT)vkGetDeviceProcAddr(m_device->device(), "vkCreateValidationCacheEXT");
12064         (PFN_vkDestroyValidationCacheEXT)vkGetDeviceProcAddr(m_device->device(), "vkDestroyValidationCacheEXT");
12066         (PFN_vkMergeValidationCachesEXT)vkGetDeviceProcAddr(m_device->device(), "vkMergeValidationCachesEXT");
12079     VkResult res = fpCreateValidationCache(m_device->device(), &validationCacheCreateInfo, nullptr, &validationCache);
12083     res = fpMergeValidationCaches(m_device->device(), validationCache, 1, &validationCache);
12086     fpDestroyValidationCache(m_device->device(), validationCache, nullptr);
12099     VkImageObj image(m_device);
12118     VkCommandBufferObj cmdbuf(m_device, m_commandPool);
12146     VkResult err = vkCreateBuffer(m_device->device(), &buf_info, NULL, &buffer);
12150     vkGetBufferMemoryRequirements(m_device->device(), buffer, &requirements);
12157     bool pass = m_device->phy().set_memory_type(requirements.memoryTypeBits, &alloc_info, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
12161     err = vkAllocateMemory(m_device->device(), &alloc_info, NULL, &memory);
12164     err = vkBindBufferMemory(m_device->device(), buffer, memory, 0);
12177     vkFreeMemory(m_device->device(), memory, NULL);
12178     vkDestroyBuffer(m_device->device(), buffer, NULL);
12202     vkCreateBuffer(m_device->device(), &buffCI, NULL, &ib);
12205     if (m_device->queue_props.size() > 2) {
12213         vkCreateBuffer(m_device->device(), &buffCI, NULL, &ib2);
12216         vkGetBufferMemoryRequirements(m_device->device(), ib2, &mem_reqs);
12222         pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
12224             vkDestroyBuffer(m_device->device(), ib2, NULL);
12227         vkAllocateMemory(m_device->device(), &alloc_info, NULL, &mem);
12228         vkBindBufferMemory(m_device->device(), ib2, mem, 0);
12235         vkDestroyBuffer(m_device->device(), ib2, NULL);
12236         vkFreeMemory(m_device->device(), mem, NULL);
12247     VkCommandBufferObj cb(m_device, m_commandPool);
12273     ds_pool.init(*m_device, vk_testing::DescriptorPool::create_info(0, VK_DESCRIPTOR_TYPE_RANGE_SIZE, ds_type_count));
12292         ds_layouts.push_back(UpDescriptorSetLayout(new VkDescriptorSetLayoutObj(m_device, dsl_bindings)));
12293         descriptor_sets.push_back(UpDescriptorSet(ds_pool.alloc_sets(*m_device, *ds_layouts.back())));
12300     VkConstantBufferObj buffer(m_device, buffer_size, data, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT);
12301     VkConstantBufferObj storage_texel_buffer(m_device, buffer_size, data, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT);
12306     buffer_view_obj.init(*m_device, buff_view_ci);
12308     storage_texel_buffer_view_obj.init(*m_device, buff_view_ci);
12314     VkImageObj image_obj(m_device);
12355         vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12373     OneOffDescriptorSet ds(m_device, {
12381     buff_ci.size = m_device->props.limits.minUniformBufferOffsetAlignment;
12384     err = vkCreateBuffer(m_device->device(), &buff_ci, NULL, &buffer);
12389     vkGetBufferMemoryRequirements(m_device->device(), buffer, &mem_reqs);
12395     bool pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0);
12397         vkDestroyBuffer(m_device->device(), buffer, NULL);
12402     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
12404     err = vkBindBufferMemory(m_device->device(), buffer, mem, 0);
12424     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12432     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12440     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12443     vkFreeMemory(m_device->device(), mem, NULL);
12444     vkDestroyBuffer(m_device->device(), buffer, NULL);
12470                        m_device->props.limits.maxUniformBufferRange, VALIDATION_ERROR_15c00298,
12471                        m_device->props.limits.minUniformBufferOffsetAlignment, VALIDATION_ERROR_15c0028e}),
12473                        m_device->props.limits.maxStorageBufferRange, VALIDATION_ERROR_15c0029a,
12474                        m_device->props.limits.minStorageBufferOffsetAlignment, VALIDATION_ERROR_15c00290}),
12477         OneOffDescriptorSet ds(m_device, {
12488         err = vkCreateBuffer(m_device->device(), &bci, NULL, &buffer);
12493         vkGetBufferMemoryRequirements(m_device->device(), buffer, &mem_reqs);
12499         bool pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0);
12502             vkDestroyBuffer(m_device->device(), buffer, NULL);
12507         err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
12510             vkDestroyBuffer(m_device->device(), buffer, NULL);
12513         err = vkBindBufferMemory(m_device->device(), buffer, mem, 0);
12533             vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12542             vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12547         vkFreeMemory(m_device->device(), mem, NULL);
12548         vkDestroyBuffer(m_device->device(), buffer, NULL);
12565     OneOffDescriptorSet ds(m_device, {
12585     err = vkCreateImage(m_device->device(), &image_ci, NULL, &image);
12596     vkGetImageMemoryRequirements(m_device->device(), image, &mem_reqs);
12598     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0);
12600     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &image_mem);
12602     err = vkBindImageMemory(m_device->device(), image, image_mem, 0);
12617     err = vkCreateImageView(m_device->device(), &image_view_ci, NULL, &image_view);
12634     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12637     vkDestroyImage(m_device->device(), image, NULL);
12638     vkFreeMemory(m_device->device(), image_mem, NULL);
12639     vkDestroyImageView(m_device->device(), image_view, NULL);
12651     OneOffDescriptorSet ds(m_device, {
12657     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
12672     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12676     vkDestroySampler(m_device->device(), sampler, NULL);
12684     OneOffDescriptorSet ds(m_device, {
12688     VkBufferTest buffer_test(m_device, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
12710     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12722     OneOffDescriptorSet ds(m_device, {
12728     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
12744     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12748     vkDestroySampler(m_device->device(), sampler, NULL);
12757     OneOffDescriptorSet ds(m_device, {
12763     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
12780     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12783     vkDestroySampler(m_device->device(), sampler, NULL);
12795     OneOffDescriptorSet ds(m_device, {
12801     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
12816     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12820     vkDestroySampler(m_device->device(), sampler, NULL);
12828     OneOffDescriptorSet ds(m_device, {
12847     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12860     OneOffDescriptorSet ds(m_device, {
12866     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
12885     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12889     vkDestroySampler(m_device->device(), sampler, NULL);
12901     OneOffDescriptorSet ds(m_device, {
12908     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
12923     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
12933     vkUpdateDescriptorSets(m_device->device(), 0, NULL, 1, &copy_ds_update);
12945     vkUpdateDescriptorSets(m_device->device(), 0, NULL, 1, &copy_ds_update);
12961     vkUpdateDescriptorSets(m_device->device(), 0, NULL, 1, &copy_ds_update);
12965     vkDestroySampler(m_device->device(), sampler, NULL);
12973     OneOffDescriptorSet src_ds(m_device, {
12978     OneOffDescriptorSet dst_ds(m_device, {
12996     vkUpdateDescriptorSets(m_device->device(), 0, NULL, copy_size, copy_ds_update);
13009     OneOffDescriptorSet ds(m_device, {
13021     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
13023     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
13024     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);  // We shouldn't need a fragment shader
13026     VkPipelineObj pipe(m_device);
13060     OneOffDescriptorSet ds(m_device, {
13064     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
13066     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
13067     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);  // We shouldn't need a fragment shader
13087     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
13088     VkPipelineObj pipe(m_device);
13121     vkDestroyRenderPass(m_device->device(), rp, NULL);
13133     OneOffDescriptorSet ds(m_device, {
13145     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
13147     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
13148     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);  // We shouldn't need a fragment shader
13150     VkPipelineObj pipe(m_device);
13173     OneOffDescriptorSet set(m_device, {
13192     VkImageObj image(m_device);
13208     err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
13217     vkUpdateDescriptorSets(m_device->device(), 1, &write, 0, nullptr);
13221     vkDestroyImageView(m_device->device(), view, nullptr);
13241     VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
13283     OneOffDescriptorSet ds(m_device, {
13295     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
13297     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
13300     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
13302     VkPipelineObj pipe(m_device);
13361     OneOffDescriptorSet ds(m_device, {
13373     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
13375     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
13376     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);  // We shouldn't need a fragment shader
13378     VkPipelineObj pipe(m_device);
13392     VkConstantBufferObj vbo(m_device, sizeof(vbo_data), (const void *)&vbo_data, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
13420     VkPhysicalDeviceFeatures features = m_device->phy().features();
13435     vk_testing::QueueCreateInfoArray queue_info_obj(m_device->queue_props);
13465     vk_testing::QueueCreateInfoArray queue_info(m_device->queue_props);
13469     auto features = m_device->phy().features();
13505     vkCreateEvent(m_device->device(), &event_create_info, nullptr, &event);
13508     vkGetDeviceQueue(m_device->device(), m_device->graphics_queue_node_index_, 0, &queue);
13518     vkCreateQueryPool(m_device->device(), &query_pool_create_info, nullptr, &query_pool);
13526     vkDestroyQueryPool(m_device->device(), query_pool, nullptr);
13527     vkDestroyEvent(m_device->device(), event, nullptr);
13553     const VkPipelineLayoutObj pipeline_layout(m_device);
13555     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
13556     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
13557     VkPipelineObj pipe(m_device);
13574         VkVerticesObj draw_verticies(m_device, 1, 1, sizeof(vbo_data[0]), sizeof(vbo_data) / sizeof(vbo_data[0]), vbo_data);
13591         VkBufferTest buffer_test(m_device, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VkBufferTest::eDoubleDelete);
13598     if (VkBufferTest::GetTestConditionValid(m_device, VkBufferTest::eInvalidMemoryOffset)) {
13604         VkBufferTest buffer_test(m_device, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, VkBufferTest::eInvalidMemoryOffset);
13609     if (VkBufferTest::GetTestConditionValid(m_device, VkBufferTest::eInvalidDeviceOffset,
13617         VkBufferTest buffer_test(m_device, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, VkBufferTest::eInvalidDeviceOffset);
13622     if (VkBufferTest::GetTestConditionValid(m_device, VkBufferTest::eInvalidDeviceOffset, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)) {
13629         VkBufferTest buffer_test(m_device, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VkBufferTest::eInvalidDeviceOffset);
13634     if (VkBufferTest::GetTestConditionValid(m_device, VkBufferTest::eInvalidDeviceOffset, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)) {
13641         VkBufferTest buffer_test(m_device, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VkBufferTest::eInvalidDeviceOffset);
13650         VkBufferTest buffer_test(m_device, 0, VkBufferTest::eBindNullBuffer);
13658         VkBufferTest buffer_test(m_device, 0, VkBufferTest::eBindFakeBuffer);
13666         VkBufferTest buffer_test(m_device, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VkBufferTest::eFreeInvalidHandle);
13678     VkConstantBufferObj vbo(m_device, sizeof(vbo_data), (const void *)&vbo_data, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
13727     VkResult err = vkCreateImage(m_device->device(), &image_create_info, NULL, &src_image);
13730     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dst_image);
13734     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &depth_image);
13746     vkGetImageMemoryRequirements(m_device->device(), src_image, &img_mem_reqs);
13748     bool pass = m_device->phy().set_memory_type(img_mem_reqs.memoryTypeBits, &mem_alloc, 0);
13750     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &src_image_mem);
13753     vkGetImageMemoryRequirements(m_device->device(), dst_image, &img_mem_reqs);
13755     pass = m_device->phy().set_memory_type(img_mem_reqs.memoryTypeBits, &mem_alloc, 0);
13757     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &dst_image_mem);
13760     vkGetImageMemoryRequirements(m_device->device(), depth_image, &img_mem_reqs);
13762     pass = m_device->phy().set_memory_type(img_mem_reqs.memoryTypeBits, &mem_alloc, 0);
13764     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &depth_image_mem);
13767     err = vkBindImageMemory(m_device->device(), src_image, src_image_mem, 0);
13769     err = vkBindImageMemory(m_device->device(), dst_image, dst_image_mem, 0);
13771     err = vkBindImageMemory(m_device->device(), depth_image, depth_image_mem, 0);
13933     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
13941     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
13950     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
13957     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
13965     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
13972     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
13988     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
13991     vkFreeMemory(m_device->device(), src_image_mem, NULL);
13992     vkFreeMemory(m_device->device(), dst_image_mem, NULL);
13993     vkFreeMemory(m_device->device(), depth_image_mem, NULL);
13994     vkDestroyImage(m_device->device(), src_image, NULL);
13995     vkDestroyImage(m_device->device(), dst_image, NULL);
13996     vkDestroyImage(m_device->device(), depth_image, NULL);
14017     OneOffDescriptorSet ds(m_device, {
14021     VkImageObj image(m_device);
14041     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
14050     VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
14074     VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
14101     VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
14133     vkAllocateCommandBuffers(m_device->device(), &alloc_info, cmd_bufs);
14151     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
14153     vkQueueWaitIdle(m_device->m_queue);
14162     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
14164     vkQueueWaitIdle(m_device->m_queue);
14176     auto features = m_device->phy().features();
14231     vkCreateEvent(m_device->device(), &event_create_info, nullptr, &event);
14235     vkDestroyEvent(m_device->device(), event, nullptr);
14242     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
14259     ASSERT_VK_SUCCESS(vkCreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore));
14263     ASSERT_VK_SUCCESS(vkCreateFence(m_device->device(), &fence_create_info, nullptr, &fence));
14265     OneOffDescriptorSet ds(m_device, {
14269     VkBufferTest buffer_test(m_device, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
14283     vkUpdateDescriptorSets(m_device->device(), 1, &write_descriptor_set, 0, nullptr);
14285     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
14286     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
14288     VkPipelineObj pipe(m_device);
14293     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
14300     vkCreateEvent(m_device->device(), &event_create_info, nullptr, &event);
14318     vkQueueSubmit(m_device->m_queue, 1, &submit_info, fence);
14322     vkDestroyEvent(m_device->device(), event, nullptr);
14326     vkDestroySemaphore(m_device->device(), semaphore, nullptr);
14330     vkDestroyFence(m_device->device(), fence, nullptr);
14333     vkQueueWaitIdle(m_device->m_queue);
14336     vkDestroySemaphore(m_device->device(), semaphore, nullptr);
14339     vkDestroyFence(m_device->device(), fence, nullptr);
14342     vkDestroyEvent(m_device->device(), event, nullptr);
14356     vkCreateQueryPool(m_device->device(), &query_pool_ci, nullptr, &query_pool);
14366     vkGetQueryPoolResults(m_device->handle(), query_pool, 0, 1, sizeof(data_space), &data_space, sizeof(uint32_t),
14375     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
14378     vkDestroyQueryPool(m_device->handle(), query_pool, NULL);
14381     vkQueueWaitIdle(m_device->m_queue);
14385     vkDestroyQueryPool(m_device->handle(), query_pool, NULL);
14394     const VkPipelineLayoutObj pipeline_layout(m_device);
14398     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
14399     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
14403         VkPipelineObj pipe(m_device);
14421         vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
14425     vkQueueWaitIdle(m_device->m_queue);
14428     vkDestroyPipeline(m_device->handle(), delete_this_pipeline, nullptr);
14442     vkGetPhysicalDeviceMemoryProperties(m_device->phy().handle(), &memProps);
14460     VkImageObj image1D(m_device);
14481     vkCreateImageView(m_device->device(), &ivci, NULL, &imageView);
14500     VkImageObj image2D(m_device);
14520     vkCreateImageView(m_device->device(), &ivci, NULL, &imageView);
14529     vkCreateImageView(m_device->device(), &ivci, NULL, &imageView);
14548     VkImageObj image3D(m_device);
14568     vkCreateImageView(m_device->device(), &ivci, NULL, &imageView);
14581     vkCreateImageView(m_device->device(), &ivci, NULL, &imageView);
14587         m_device->phy().handle(), VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TYPE_3D, VK_IMAGE_TILING_OPTIMAL,
14593     if (res || !m_device->phy().features().sparseBinding ||
14619     res = vkCreateImage(m_device->device(), &imgInfo, NULL, &imageSparse);
14638     vkCreateImageView(m_device->device(), &ivci, NULL, &imageView);
14642     vkDestroyImage(m_device->device(), imageSparse, nullptr);
14711         VkImageObj image(m_device);
14731         VkResult res = vkCreateImageView(m_device->device(), &ivci, NULL, &imageView);
14735             vkDestroyImageView(m_device->device(), imageView, nullptr);
14776     VkImageObj image(m_device);
14796     VkResult res = vkCreateImageView(m_device->device(), &ivci, NULL, &imageView);
14800         vkDestroyImageView(m_device->device(), imageView, nullptr);
14810     OneOffDescriptorSet ds(m_device, {
14818     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
14821     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
14823     VkImageObj image(m_device);
14838     err = vkCreateImageView(m_device->device(), &ivci, NULL, &view);
14854     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
14871     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
14872     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
14873     VkPipelineObj pipe(m_device);
14902     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
14904     vkDestroyImageView(m_device->device(), view, nullptr);
14906     vkQueueWaitIdle(m_device->m_queue);
14910     vkDestroyImageView(m_device->device(), view, NULL);
14911     vkDestroySampler(m_device->device(), sampler, nullptr);
14920     OneOffDescriptorSet ds(m_device, {
14924     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
14935     VkResult err = vkCreateBuffer(m_device->device(), &buffer_create_info, NULL, &buffer);
14946     vkGetBufferMemoryRequirements(m_device->device(), buffer, &memory_reqs);
14948     bool pass = m_device->phy().set_memory_type(memory_reqs.memoryTypeBits, &memory_info, 0);
14951     err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &buffer_memory);
14953     err = vkBindBufferMemory(m_device->device(), buffer, buffer_memory, 0);
14963     err = vkCreateBufferView(m_device->device(), &bvci, NULL, &view);
14974     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
14990     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
14991     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
14992     VkPipelineObj pipe(m_device);
15019     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
15021     vkDestroyBufferView(m_device->device(), view, nullptr);
15023     vkQueueWaitIdle(m_device->m_queue);
15027     vkDestroyBufferView(m_device->device(), view, NULL);
15028     vkDestroyBuffer(m_device->device(), buffer, NULL);
15029     vkFreeMemory(m_device->device(), buffer_memory, NULL);
15038     OneOffDescriptorSet ds(m_device, {
15046     err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
15049     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
15051     VkImageObj image(m_device);
15066     err = vkCreateImageView(m_device->device(), &ivci, NULL, &view);
15082     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
15099     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
15100     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
15101     VkPipelineObj pipe(m_device);
15130     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
15132     vkDestroySampler(m_device->device(), sampler, nullptr);  // Destroyed too soon
15134     vkQueueWaitIdle(m_device->m_queue);
15139     vkDestroySampler(m_device->device(), sampler, NULL);  // Destroyed for real
15140     vkDestroyImageView(m_device->device(), view, NULL);
15154     VkConstantBufferObj buffer(m_device, sizeof(data), data, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
15181     OneOffDescriptorSet good_dst(m_device, one_uniform_buffer);
15184     OneOffDescriptorSet bad_dst(m_device, one_uniform_buffer);
15189     OneOffDescriptorSet good_src(m_device, one_uniform_buffer);
15195     vkUpdateDescriptorSets(m_device->device(), 1, &write_descriptor, 0, NULL);
15198     OneOffDescriptorSet bad_src(m_device, one_uniform_buffer);
15204     vkUpdateDescriptorSets(m_device->device(), 0, nullptr, 1, &copy_descriptor);
15211     vkUpdateDescriptorSets(m_device->device(), 1, &write_descriptor, 0, NULL);
15216     vkUpdateDescriptorSets(m_device->device(), 0, nullptr, 1, &copy_descriptor);
15222     vkUpdateDescriptorSets(m_device->device(), 0, nullptr, 1, &copy_descriptor);
15237     VkCommandBufferObj cb1(m_device, m_commandPool);
15244     ASSERT_VK_SUCCESS(vkCreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore));
15251     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
15257     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
15263     ASSERT_VK_SUCCESS(vkCreateFence(m_device->device(), &fence_create_info, nullptr, &fence));
15266     vkWaitForFences(m_device->device(), 1, &fence, VK_TRUE, UINT64_MAX);
15269     vkDeviceWaitIdle(m_device->device());
15270     vkDestroyFence(m_device->device(), fence, nullptr);
15271     vkDestroySemaphore(m_device->device(), semaphore, nullptr);
15298     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
15302     VkImageObj image(m_device);
15318     err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
15323     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
15333     err = vkAllocateCommandBuffers(m_device->device(), &cbai, &sec_cb);
15356     vkDestroyImageView(m_device->device(), view, NULL);
15357     vkDestroyRenderPass(m_device->device(), rp, NULL);
15358     vkDestroyFramebuffer(m_device->device(), fb, NULL);
15367     if (!m_device->phy().features().logicOp) {
15420     VkCommandBufferObj commandBuffer(m_device, m_commandPool);
15491     vkCreateShaderModule(m_device->device(), &moduleCreateInfo, NULL, &module);
15515     vkCreateShaderModule(m_device->handle(), &module_create_info, NULL, &shader_module);
15541     vkCreateShaderModule(m_device->device(), &moduleCreateInfo, NULL, &module);
15569     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
15570     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
15572     VkPipelineObj pipe(m_device);
15577     VkDescriptorSetObj descriptorSet(m_device);
15591     if (!m_device->phy().features().tessellationShader) {
15624     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
15625     VkShaderObj tcs(m_device, tcsSource, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, this);
15626     VkShaderObj tes(m_device, tesSource, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, this);
15627     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
15634     VkPipelineObj pipe(m_device);
15644     VkDescriptorSetObj descriptorSet(m_device);
15678     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
15679     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
15681     const VkPipelineLayoutObj pipeline_layout(m_device);
15739     ASSERT_VK_SUCCESS(vkCreatePipelineCache(m_device->device(), &pipeline_cache_create_info, nullptr, &pipelineCache));
15759     vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &graphicspipe_create_info, nullptr, &pipeline);
15762     vkDestroyPipelineCache(m_device->device(), pipelineCache, nullptr);
15773     OneOffDescriptorSet ds(m_device, {
15795     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
15796     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
15798     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
15800     VkPipelineObj pipe(m_device);
15819     OneOffDescriptorSet ds(m_device, {
15841     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
15842     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
15844     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
15846     VkPipelineObj pipe(m_device);
15883     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
15884     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
15892     const VkPipelineLayoutObj pipeline_layout(m_device, {}, {push_constant_range});
15894     VkPipelineObj pipe(m_device);
15916     auto features = m_device->phy().features();
15981     vkCreateShaderModule(m_device->handle(), &module_create_info, NULL, &shader_module);
16001     if (!m_device->phy().features().multiViewport) {
16015     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16017     VkPipelineObj pipe(m_device);
16021     const VkPipelineLayoutObj pipe_layout(m_device, {});
16042     if (!m_device->phy().features().multiViewport) {
16056     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16058     VkPipelineObj pipe(m_device);
16062     const VkPipelineLayoutObj pipe_layout(m_device, {});
16093     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16094     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16096     VkPipelineObj pipe(m_device);
16101     VkDescriptorSetObj descriptorSet(m_device);
16134     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16135     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16137     VkPipelineObj pipe(m_device);
16142     VkDescriptorSetObj descriptorSet(m_device);
16177     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16178     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16180     VkPipelineObj pipe(m_device);
16185     VkDescriptorSetObj descriptorSet(m_device);
16218     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16219     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16221     VkPipelineObj pipe(m_device);
16226     VkDescriptorSetObj descriptorSet(m_device);
16261     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16262     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16264     VkPipelineObj pipe(m_device);
16269     VkDescriptorSetObj descriptorSet(m_device);
16304     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16305     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16307     VkPipelineObj pipe(m_device);
16312     VkDescriptorSetObj descriptorSet(m_device);
16347     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16348     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16350     VkPipelineObj pipe(m_device);
16355     VkDescriptorSetObj descriptorSet(m_device);
16380     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16381     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16383     VkPipelineObj pipe(m_device);
16388     VkDescriptorSetObj descriptorSet(m_device);
16415     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16416     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16418     VkPipelineObj pipe(m_device);
16423     VkDescriptorSetObj descriptorSet(m_device);
16462     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16463     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16465     VkPipelineObj pipe(m_device);
16473     VkDescriptorSetObj descriptorSet(m_device);
16513     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16514     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16516     VkPipelineObj pipe(m_device);
16524     VkDescriptorSetObj descriptorSet(m_device);
16557     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16558     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16560     VkPipelineObj pipe(m_device);
16565     VkDescriptorSetObj descriptorSet(m_device);
16605     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16606     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16608     VkPipelineObj pipe(m_device);
16616     VkDescriptorSetObj descriptorSet(m_device);
16647     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16648     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16650     VkPipelineObj pipe(m_device);
16656     VkDescriptorSetObj descriptorSet(m_device);
16684     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16685     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this, "foo");
16687     VkPipelineObj pipe(m_device);
16692     VkDescriptorSetObj descriptorSet(m_device);
16720     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16721     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16723     VkPipelineObj pipe(m_device);
16728     VkDescriptorSetObj descriptorSet(m_device);
16763     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
16770     vkDestroyRenderPass(m_device->device(), rp, nullptr);
16784     if (!m_device->phy().features().tessellationShader) {
16816     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16817     VkShaderObj tcs(m_device, tcsSource, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, this);
16818     VkShaderObj tes(m_device, tesSource, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, this);
16819     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16826     VkPipelineObj pipe(m_device);
16835     VkDescriptorSetObj descriptorSet(m_device);
16850     if (!m_device->phy().features().tessellationShader) {
16879     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
16880     VkShaderObj tcs(m_device, tcsSource, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, this);
16881     VkShaderObj tes(m_device, tesSource, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, this);
16882     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
16889     VkDescriptorSetObj descriptorSet(m_device);
16894         VkPipelineObj pipe(m_device);
16910         VkPipelineObj pipe(m_device);
16926         VkPipelineObj pipe(m_device);
16959         tsci_bad.patchControlPoints = m_device->props.limits.maxTessellationPatchSize + 1;
17009     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17010     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17012     VkPipelineObj pipe(m_device);
17020     VkDescriptorSetObj descriptorSet(m_device);
17049     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17050     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17052     VkPipelineObj pipe(m_device);
17060     VkDescriptorSetObj descriptorSet(m_device);
17089     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17090     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17092     VkPipelineObj pipe(m_device);
17100     VkDescriptorSetObj descriptorSet(m_device);
17133     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17134     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17136     VkPipelineObj pipe(m_device);
17145     VkDescriptorSetObj descriptorSet(m_device);
17176     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17177     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17179     VkPipelineObj pipe(m_device);
17187     VkDescriptorSetObj descriptorSet(m_device);
17219     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17220     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17222     VkPipelineObj pipe(m_device);
17230     VkDescriptorSetObj descriptorSet(m_device);
17260     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17261     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17263     VkPipelineObj pipe(m_device);
17271     VkDescriptorSetObj descriptorSet(m_device);
17304     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17305     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17307     VkPipelineObj pipe(m_device);
17314     const VkDescriptorSetLayoutObj dsl(m_device, {dslb});
17316     const VkPipelineLayoutObj pl(m_device, {&dsl});
17348     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17349     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17351     VkPipelineObj pipe(m_device);
17358     const VkDescriptorSetLayoutObj dsl(m_device, {dslb});
17360     const VkPipelineLayoutObj pl(m_device, {&dsl});
17382     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
17390     vkDestroyRenderPass(m_device->device(), rp, nullptr);
17417     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17418     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17420     VkPipelineObj pipe(m_device);
17427     const VkDescriptorSetLayoutObj dsl(m_device, {dslb});
17429     const VkPipelineLayoutObj pl(m_device, {&dsl});
17454     VkShaderObj cs(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
17456     VkDescriptorSetObj descriptorSet(m_device);
17469     VkResult err = vkCreateComputePipelines(m_device->device(), VK_NULL_HANDLE, 1, &cpci, nullptr, &pipe);
17474         vkDestroyPipeline(m_device->device(), pipe, nullptr);
17486     const VkDescriptorSetLayoutObj dsl(m_device, {binding});
17488     const VkPipelineLayoutObj pl(m_device, {&dsl});
17498     VkShaderObj cs(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
17510     VkResult err = vkCreateComputePipelines(m_device->device(), VK_NULL_HANDLE, 1, &cpci, nullptr, &pipe);
17515         vkDestroyPipeline(m_device->device(), pipe, nullptr);
17540     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17541     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17543     VkPipelineObj pipe(m_device);
17548     VkTextureObj texture(m_device, nullptr);
17549     VkSamplerObj sampler(m_device);
17551     VkDescriptorSetObj descriptorSet(m_device);
17600     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
17601     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
17603     VkPipelineObj pipe(m_device);
17608     VkTextureObj texture(m_device, nullptr);  // THIS LINE CAUSES CRASH ON MALI
17609     VkSamplerObj sampler(m_device);
17611     VkDescriptorSetObj descriptorSet(m_device);
17679         vkCreateImage(m_device->device(), &info, NULL, &image);
17693         vkCreateImage(m_device->device(), &bad_info, NULL, &image);
17703         vkCreateImage(m_device->device(), &bad_info, NULL, &image);
17734     VkResult result = vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
17739         vkDestroyRenderPass(m_device->device(), rp, NULL);
17773     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
17776         vkDestroyRenderPass(m_device->device(), rp, NULL);
17781     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
17784         vkDestroyRenderPass(m_device->device(), rp, NULL);
17817     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
17831     err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
17834     vkDestroyImage(m_device->device(), image, NULL);
17837         vkDestroyImageView(m_device->device(), view, NULL);
17848     VkImageObj image(m_device);
17864     vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
17878         VkImageObj img(m_device);
17888         vkGetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout);
17894         VkImageObj img(m_device);
17905         vkGetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout);
17911         VkImageObj img(m_device);
17921         vkGetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout);
17927         VkImageObj img(m_device);
17937         vkGetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout);
17972     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
17976     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
17986     vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
17988     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
17990     err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
17993     vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
17995     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
17997     err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
18000     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
18002     err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
18030     vkDestroyImage(m_device->device(), srcImage, NULL);
18031     vkDestroyImage(m_device->device(), dstImage, NULL);
18032     vkFreeMemory(m_device->device(), srcMem, NULL);
18033     vkFreeMemory(m_device->device(), destMem, NULL);
18060     vkCreateImage(m_device->handle(), &image_create_info, NULL, &image);
18067         VkFormatProperties fProps = m_device->format_properties(format);
18078         vkCreateImage(m_device->handle(), &image_create_info, NULL, &image);
18114     VkImageObj image(m_device);
18133     vkCreateImageView(m_device->handle(), &imgViewInfo, NULL, &imgView);
18153     VkImageObj image(m_device);
18177     vkCreateImageView(m_device->handle(), &imgViewInfo, NULL, &imgView);
18186     if (!(m_device->format_properties(VK_FORMAT_R8_UINT).optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) {
18206     VkImageObj mutImage(m_device);
18222     vkCreateImageView(m_device->handle(), &imgViewInfo, NULL, &imgView);
18231     VkImageObj image(m_device);
18255         vkCreateImageView(m_device->handle(), &img_view_info, nullptr, &img_view);
18266         vkCreateImageView(m_device->handle(), &img_view_info, nullptr, &img_view);
18276         vkCreateImageView(m_device->handle(), &img_view_info, nullptr, &img_view);
18286         vkCreateImageView(m_device->handle(), &img_view_info, nullptr, &img_view);
18296         vkCreateImageView(m_device->handle(), &img_view_info, nullptr, &img_view);
18307         vkCreateImageView(m_device->handle(), &img_view_info, nullptr, &img_view);
18321         vkCreateImageView(m_device->handle(), &img_view_info, nullptr, &img_view);
18331         vkCreateImageView(m_device->handle(), &img_view_info, nullptr, &img_view);
18372     VkImageObj image(m_device);
18376     VkImageObj odd_image(m_device);
18384     buffer_1024.init_as_src_and_dst(*m_device, 1024, reqs);
18385     buffer_64.init_as_src_and_dst(*m_device, 64, reqs);
18386     buffer_16.init_as_src_and_dst(*m_device, 16, reqs);
18387     buffer_8.init_as_src_and_dst(*m_device, 8, reqs);
18500     VkFormatProperties format_props = m_device->format_properties(VK_FORMAT_D24_UNORM_S8_UINT);
18507     auto index = m_device->graphics_queue_node_index_;
18508     auto queue_family_properties = m_device->phy().queue_properties();
18516     VkImageObj image_64k(m_device);        // 128^2 texels, 64k
18517     VkImageObj image_16k(m_device);        // 64^2 texels, 16k
18518     VkImageObj image_16k_depth(m_device);  // 64^2 texels, depth, 16k
18519     VkImageObj ds_image_4D_1S(m_device);   // 256^2 texels, 512kb (256k depth, 64k stencil, 192k pack)
18520     VkImageObj ds_image_3D_1S(m_device);   // 256^2 texels, 256kb (192k depth, 64k stencil)
18521     VkImageObj ds_image_2D(m_device);      // 256^2 texels, 128k (128k depth)
18522     VkImageObj ds_image_1S(m_device);      // 256^2 texels, 64k (64k stencil)
18539     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT_S8_UINT, &props);
18541     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D24_UNORM_S8_UINT, &props);
18543     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D16_UNORM, &props);
18545     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_S8_UINT, &props);
18577     buffer_256k.init_as_src_and_dst(*m_device, 262144, reqs);  // 256k
18578     buffer_128k.init_as_src_and_dst(*m_device, 131072, reqs);  // 128k
18579     buffer_64k.init_as_src_and_dst(*m_device, 65536, reqs);    // 64k
18580     buffer_16k.init_as_src_and_dst(*m_device, 16384, reqs);    // 16k
18786         VkImageObj image_16k_4x4comp(m_device);   // 128^2 texels as 32^2 compressed (4x4) blocks, 16k
18787         VkImageObj image_NPOT_4x4comp(m_device);  // 130^2 texels as 33^2 compressed (4x4) blocks
18887     VkImageObj image(m_device);
18892     buffer.init_as_src(*m_device, 128 * 128 * 8, reqs);
18903     VkImageObj image2(m_device);
18908     buffer2.init_as_src(*m_device, 128 * 128 * 2, reqs2);
18978     VkImageObj intImage1(m_device);
18981     VkImageObj intImage2(m_device);
19016         vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), format, &properties);
19056         vkCreateImage(m_device->handle(), &image_create_info, NULL, &nullImg);
19067         vkCreateImage(m_device->handle(), &image_create_info, NULL, &nullImg);
19075     vkCreateImage(m_device->handle(), &image_create_info, NULL, &nullImg);
19086         vkCreateImage(m_device->handle(), &image_create_info, NULL, &nullImg);
19095     vkCreateImage(m_device->handle(), &image_create_info, NULL, &nullImg);
19111     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), format, &fmt_props);
19114         vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), format, &fmt_props);
19137     const VkPhysicalDeviceLimits dev_limits = m_device->props.limits;
19142     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19149     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19157     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19167     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19176     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19180     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19184     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19191     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19199     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19205     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19210     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19215     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19224     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19230     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19242     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19254     vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19271         vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19281         vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19295         vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19305         vkCreateImage(m_device->handle(), &image_ci, NULL, &image);
19332     VkImageObj image_1D(m_device);
19339     VkImageObj image_2D(m_device);
19346     VkImageObj image_3D(m_device);
19354     VkImageObj image_2D_array(m_device);
19484     VkImageObj image_1D(m_device);
19491     VkImageObj image_2D(m_device);
19498     VkImageObj image_3D(m_device);
19506     VkImageObj image_2D_array(m_device);
19586     if (VK_SUCCESS != vkGetPhysicalDeviceImageFormatProperties(m_device->phy().handle(), ci.format, ci.imageType, ci.tiling,
19593     VkImageObj image_1(m_device);
19598     VkImageObj image_2(m_device);
19698     VkImageObj src_image(m_device);
19706     VkImageObj dst_image(m_device);
19782     VkImageObj dst_image(m_device);
19790     VkImageObj src_image(m_device);
19875     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
19882     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), image_create_info.format, &properties);
19884         vkDestroyImage(m_device->device(), srcImage, NULL);
19889     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
19899     vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
19901     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
19903     err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
19906     vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
19908     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
19910     err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
19913     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
19915     err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
19942     vkDestroyImage(m_device->device(), srcImage, NULL);
19943     vkDestroyImage(m_device->device(), dstImage, NULL);
19944     vkFreeMemory(m_device->device(), srcMem, NULL);
19945     vkFreeMemory(m_device->device(), destMem, NULL);
19956     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT, &properties);
19962     VkImageObj srcImage(m_device);
19965     VkImageObj dstImage(m_device);
20033     VkImageObj image1(m_device);
20038     VkImageObj image2(m_device);
20043     VkImageObj image4(m_device);
20096     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT, &properties);
20101     VkImageObj color_image(m_device), ds_image(m_device), depth_image(m_device);
20207     VkImageObj srcImage(m_device);
20211     VkImageObj dstImage(m_device);
20267     VkImageObj srcImage(m_device);
20271     VkImageObj dstImage(m_device);
20337     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
20347     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
20357     vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
20359     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
20361     err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
20364     vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
20366     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
20368     err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
20371     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
20373     err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
20403     vkDestroyImage(m_device->device(), srcImage, NULL);
20404     vkDestroyImage(m_device->device(), dstImage, NULL);
20405     vkFreeMemory(m_device->device(), srcMem, NULL);
20406     vkFreeMemory(m_device->device(), destMem, NULL);
20442     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
20451     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
20461     vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
20463     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
20465     err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
20468     vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
20470     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
20472     err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
20475     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
20477     err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
20507     vkDestroyImage(m_device->device(), srcImage, NULL);
20508     vkDestroyImage(m_device->device(), dstImage, NULL);
20509     vkFreeMemory(m_device->device(), srcMem, NULL);
20510     vkFreeMemory(m_device->device(), destMem, NULL);
20542     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
20552     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
20560     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
20586     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image_bad);
20590     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image_good);
20595     vkGetImageMemoryRequirements(m_device->device(), image_bad, &img_mem_reqs);
20602         m_device->phy().set_memory_type(img_mem_reqs.memoryTypeBits, &image_alloc_info, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
20605     err = vkAllocateMemory(m_device->device(), &image_alloc_info, NULL, &mem);
20607     err = vkBindImageMemory(m_device->device(), image_bad, mem, 0);
20623     err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
20627     vkDestroyImage(m_device->device(), image_bad, NULL);
20628     vkDestroyImage(m_device->device(), image_good, NULL);
20629     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
20631     vkFreeMemory(m_device->device(), mem, NULL);
20664     color_image_no_transfer.init(*m_device, image_create_info, reqs);
20668     color_image.init(*m_device, image_create_info, reqs);
20684     ds_image.init(*m_device, ds_image_create_info, reqs);
20718     uint32_t queueFamilyIndex = m_device->QueueFamilyWithoutCapabilities(VK_QUEUE_GRAPHICS_BIT);
20724         VkCommandPoolObj command_pool(m_device, queueFamilyIndex);
20727         VkCommandBufferObj command_buffer(m_device, &command_pool);
20741     VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
20762     vkQueueSubmit(m_device->m_queue, 1, &si, VK_NULL_HANDLE);
20773         (PFN_vkTrimCommandPoolKHR)vkGetDeviceProcAddr(m_device->handle(), "vkTrimCommandPoolKHR");
20780     vkTrimCommandPoolKHR(m_device->handle(), m_commandPool->handle(), (VkCommandPoolTrimFlagsKHR)0);
20795     vk_testing::QueueCreateInfoArray queue_info(m_device->queue_props);
20799     auto features = m_device->phy().features();
20841             vkCreateDescriptorPool(m_device->device(), &invalid_dp_ci, nullptr, &pool);
20857             vkCreateDescriptorPool(m_device->device(), &dp_ci, nullptr, &pool);
20875     vkCreateBuffer(m_device->device(), &info, nullptr, &buffer);
20898     VkImageObj uncomp_10x10t_image(m_device);       // Size = 10 * 10 * 64 = 6400
20899     VkImageObj comp_10x10b_40x40t_image(m_device);  // Size = 40 * 40 * 4  = 6400
20963     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool_one);
20975         const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
20982         err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
20985     err = vkFreeDescriptorSets(m_device->device(), ds_pool_one, 1, &descriptorSet);
20987     vkDestroyDescriptorPool(m_device->device(), ds_pool_one, NULL);
20998     cmd_pool_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
21003     VkResult res = vkCreateCommandPool(m_device->handle(), &cmd_pool_info, NULL, &secondary_cmd_pool);
21010     res = vkAllocateCommandBuffers(m_device->handle(), &cmdalloc, &secondary_cmds);
21037     vkDestroyCommandPool(m_device->handle(), secondary_cmd_pool, NULL);
21039     res = vkResetCommandPool(m_device->handle(), m_commandPool->handle(), 0);
21055     ASSERT_VK_SUCCESS(vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &secondary_command_buffer));
21097     ASSERT_VK_SUCCESS(vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &secondary_command_buffer));
21100     ASSERT_VK_SUCCESS(vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &primary_command_buffer));
21110     VkImageObj image(m_device);
21159     err = vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
21162     err = vkDeviceWaitIdle(m_device->device());
21164     vkFreeCommandBuffers(m_device->device(), m_commandPool->handle(), 1, &secondary_command_buffer);
21165     vkFreeCommandBuffers(m_device->device(), m_commandPool->handle(), 1, &primary_command_buffer);
21183         VkImageObj image(m_device);
21188         OneOffDescriptorSet ds(m_device, {
21214         vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
21232         VkResult err = vkCreateBuffer(m_device->device(), &buffer_create_info, NULL, &buffer);
21244         vkGetBufferMemoryRequirements(m_device->device(), buffer, &memory_reqs);
21246         pass = m_device->phy().set_memory_type(memory_reqs.memoryTypeBits, &memory_info, 0);
21249         err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &buffer_memory);
21251         err = vkBindBufferMemory(m_device->device(), buffer, buffer_memory, 0);
21254         OneOffDescriptorSet ds(m_device, {
21281         vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
21285         vkDestroyBuffer(m_device->device(), buffer, NULL);
21286         vkFreeMemory(m_device->device(), buffer_memory, NULL);
21302         VkResult err = vkCreateBuffer(m_device->device(), &buffer_create_info, NULL, &buffer);
21314         vkGetBufferMemoryRequirements(m_device->device(), buffer, &memory_reqs);
21316         pass = m_device->phy().set_memory_type(memory_reqs.memoryTypeBits, &memory_info, 0);
21319         err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &buffer_memory);
21321         err = vkBindBufferMemory(m_device->device(), buffer, buffer_memory, 0);
21330         err = vkCreateBufferView(m_device->device(), &buff_view_ci, NULL, &buffer_view);
21332         OneOffDescriptorSet ds(m_device, {
21354         vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
21358         vkDestroyBufferView(m_device->device(), buffer_view, NULL);
21359         vkDestroyBuffer(m_device->device(), buffer, NULL);
21360         vkFreeMemory(m_device->device(), buffer_memory, NULL);
21370     OneOffDescriptorSet ds(m_device, {
21376     VkResult err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
21379     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
21389     vkDestroySampler(m_device->device(), sampler, NULL);
21423     vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
21455     vkGetPhysicalDeviceProperties2KHR(m_device->phy().handle(), &prop2);
21468         vkCreateDescriptorSetLayout(m_device->handle(), &ds_layout_ci, nullptr, &ds_layout);
21470         vkDestroyDescriptorSetLayout(m_device->handle(), ds_layout, nullptr);
21507     vkCreateDescriptorSetLayout(m_device->handle(), &ds_layout_ci, nullptr, &ds_layout);
21509     vkDestroyDescriptorSetLayout(m_device->handle(), ds_layout, nullptr);
21536     VkResult err = vkCreateDescriptorSetLayout(m_device->handle(), &ds_layout_ci, nullptr, &ds_layout);
21545     err = vkCreateDescriptorPool(m_device->handle(), &dspci, nullptr, &pool);
21555     vkAllocateDescriptorSets(m_device->handle(), &ds_alloc_info, &ds);
21558     vkDestroyDescriptorPool(m_device->handle(), pool, nullptr);
21559     vkDestroyDescriptorSetLayout(m_device->handle(), ds_layout, nullptr);
21582     const VkDescriptorSetLayoutObj ds_layout(m_device, {binding});
21584     const VkDescriptorSetLayoutObj push_ds_layout(m_device, {binding}, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR);
21588     const VkPipelineLayoutObj pipeline_layout(m_device, {&push_ds_layout, &ds_layout});
21593     VkConstantBufferObj buffer_obj(m_device, sizeof(buffer_data), &buffer_data);
21605         (PFN_vkCmdPushDescriptorSetKHR)vkGetDeviceProcAddr(m_device->device(), "vkCmdPushDescriptorSetKHR");
21610     const uint32_t no_gfx_qfi = m_device->QueueFamilyMatching(VK_QUEUE_COMPUTE_BIT, VK_QUEUE_GRAPHICS_BIT);
21612         m_device->QueueFamilyMatching(VK_QUEUE_TRANSFER_BIT, (VK_QUEUE_COMPUTE_BIT | VK_QUEUE_GRAPHICS_BIT));
21618         VkCommandPoolObj command_pool(m_device, err_qfi);
21620         VkCommandBufferObj command_buffer(m_device, &command_pool);
21637             VkCommandPoolObj tran_command_pool(m_device, transfer_only_qfi);
21639             VkCommandBufferObj tran_command_buffer(m_device, &tran_command_pool);
21688     const VkPhysicalDeviceLimits &limits = m_device->props.limits;
21707     const VkPhysicalDeviceLimits &limits = m_device->props.limits;
21791     OneOffDescriptorSet ds(m_device, {
21804     err = vkCreateBuffer(m_device->device(), &buff_ci, NULL, &buffer);
21814     vkGetBufferMemoryRequirements(m_device->device(), buffer, &mem_reqs);
21815     bool pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0);
21817         vkDestroyBuffer(m_device->device(), buffer, NULL);
21826     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
21828     err = vkBindBufferMemory(m_device->device(), buffer, mem, 0);
21846     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
21850     vkFreeMemory(m_device->device(), mem, NULL);
21851     vkDestroyBuffer(m_device->device(), buffer, NULL);
21883         ds_layouts.emplace_back(m_device, std::vector<VkDescriptorSetLayoutBinding>(1, dsl_binding),
21898     vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
21929     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding}, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR);
21932     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds_layout});
21935     VkConstantBufferObj vbo(m_device, sizeof(vbo_data), (const void *)&vbo_data);
21953         (PFN_vkCmdPushDescriptorSetKHR)vkGetDeviceProcAddr(m_device->device(), "vkCmdPushDescriptorSetKHR");
21997     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
22008     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
22011     const VkDescriptorSetLayoutObj push_ds_layout(m_device, {dsl_binding}, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR);
22021     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptor_set);
22025     const VkPipelineLayoutObj pipeline_layout(m_device, {&push_ds_layout, &ds_layout});
22043     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
22044     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
22045     VkPipelineObj pipe(m_device);
22054     VkConstantBufferObj buffer(m_device, sizeof(bo_data), (const void *)&bo_data, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
22070     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
22073         (PFN_vkCmdPushDescriptorSetKHR)vkGetDeviceProcAddr(m_device->device(), "vkCmdPushDescriptorSetKHR");
22090     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
22119     err = vkCreateBuffer(m_device->device(), &buf_info, NULL, &buffer);
22122     vkGetBufferMemoryRequirements(m_device->device(), buffer, &mem_reqs);
22132     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
22134         vkDestroyBuffer(m_device->device(), buffer, NULL);
22138     err = vkAllocateMemory(m_device->device(), &alloc_info, NULL, &mem);
22142     err = vkMapMemory(m_device->device(), mem, 0, mem_reqs.size, 0, (void **)&pData);
22147     vkUnmapMemory(m_device->device(), mem);
22149     err = vkBindBufferMemory(m_device->device(), buffer, mem, 0);
22155     vkDestroyBuffer(m_device->device(), buffer, NULL);
22156     vkDeviceWaitIdle(m_device->device());
22165         vkFreeMemory(m_device->device(), mem, NULL);
22190     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
22193     vkGetImageMemoryRequirements(m_device->device(), image, &mem_reqs);
22202     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
22204         vkFreeMemory(m_device->device(), mem, NULL);
22205         vkDestroyImage(m_device->device(), image, NULL);
22210     err = vkBindImageMemory(m_device->device(), image, mem, 0);
22215     vkFreeMemory(m_device->device(), mem, NULL);
22216     vkDestroyImage(m_device->device(), image, NULL);
22228     vkDestroyBuffer(m_device->device(), VK_NULL_HANDLE, NULL);
22229     vkDestroyBufferView(m_device->device(), VK_NULL_HANDLE, NULL);
22230     vkDestroyCommandPool(m_device->device(), VK_NULL_HANDLE, NULL);
22231     vkDestroyDescriptorPool(m_device->device(), VK_NULL_HANDLE, NULL);
22232     vkDestroyDescriptorSetLayout(m_device->device(), VK_NULL_HANDLE, NULL);
22234     vkDestroyEvent(m_device->device(), VK_NULL_HANDLE, NULL);
22235     vkDestroyFence(m_device->device(), VK_NULL_HANDLE, NULL);
22236     vkDestroyFramebuffer(m_device->device(), VK_NULL_HANDLE, NULL);
22237     vkDestroyImage(m_device->device(), VK_NULL_HANDLE, NULL);
22238     vkDestroyImageView(m_device->device(), VK_NULL_HANDLE, NULL);
22240     vkDestroyPipeline(m_device->device(), VK_NULL_HANDLE, NULL);
22241     vkDestroyPipelineCache(m_device->device(), VK_NULL_HANDLE, NULL);
22242     vkDestroyPipelineLayout(m_device->device(), VK_NULL_HANDLE, NULL);
22243     vkDestroyQueryPool(m_device->device(), VK_NULL_HANDLE, NULL);
22244     vkDestroyRenderPass(m_device->device(), VK_NULL_HANDLE, NULL);
22245     vkDestroySampler(m_device->device(), VK_NULL_HANDLE, NULL);
22246     vkDestroySemaphore(m_device->device(), VK_NULL_HANDLE, NULL);
22247     vkDestroyShaderModule(m_device->device(), VK_NULL_HANDLE, NULL);
22252     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
22254     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
22261     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &command_buffers[1]);
22262     vkFreeCommandBuffers(m_device->device(), command_pool, 3, command_buffers);
22263     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
22278     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
22288     const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
22296     err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptor_sets[1]);
22298     vkFreeDescriptorSets(m_device->device(), ds_pool, 3, descriptor_sets);
22299     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
22301     vkFreeMemory(m_device->device(), VK_NULL_HANDLE, NULL);
22319     vkAllocateCommandBuffers(m_device->device(), &alloc_info, cmd_bufs);
22320     VkImageObj image(m_device);
22373     vkCreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore1);
22374     vkCreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore2);
22404 m_device->m_queue, 3, submit_info, VK_NULL_HANDLE);
22405     vkQueueWaitIdle(m_device->m_queue);
22407     vkDestroySemaphore(m_device->device(), semaphore1, NULL);
22408     vkDestroySemaphore(m_device->device(), semaphore2, NULL);
22422     OneOffDescriptorSet ds(m_device, {
22428     const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
22441     err = vkCreateBuffer(m_device->device(), &buffCI, NULL, &dyub1);
22446     err = vkCreateBuffer(m_device->device(), &buffCI, NULL, &dyub2);
22458     vkGetBufferMemoryRequirements(m_device->device(), dyub1, &mem_reqs1);
22460     vkGetBufferMemoryRequirements(m_device->device(), dyub2, &mem_reqs2);
22462     bool pass = m_device->phy().set_memory_type(mem_reqs1.memoryTypeBits, &mem_alloc[0], 0);
22464     pass &= m_device->phy().set_memory_type(mem_reqs2.memoryTypeBits, &mem_alloc[1], 0);
22466         vkDestroyBuffer(m_device->device(), dyub1, NULL);
22467         vkDestroyBuffer(m_device->device(), dyub2, NULL);
22472     err = vkAllocateMemory(m_device->device(), &mem_alloc[0], NULL, &mem1);
22474     err = vkBindBufferMemory(m_device->device(), dyub1, mem1, 0);
22477     err = vkAllocateMemory(m_device->device(), &mem_alloc[1], NULL, &mem2);
22479     err = vkBindBufferMemory(m_device->device(), dyub2, mem2, 0);
22503     vkUpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
22524     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
22525     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
22526     VkPipelineObj pipe(m_device);
22543     vkDestroyBuffer(m_device->device(), dyub1, NULL);
22544     vkDestroyBuffer(m_device->device(), dyub2, NULL);
22545     vkFreeMemory(m_device->device(), mem1, NULL);
22546     vkFreeMemory(m_device->device(), mem2, NULL);
22560     const VkDeviceSize atom_size = m_device->props.limits.nonCoherentAtomSize;
22570     bool pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
22573         pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &alloc_info,
22577             pass = m_device->phy().set_memory_type(
22587     err = vkAllocateMemory(m_device->device(), &alloc_info, NULL, &mem);
22592     err = vkMapMemory(m_device->device(), mem, 0, VK_WHOLE_SIZE, 0, (void **)&pData);
22599     err = vkFlushMappedMemoryRanges(m_device->device(), 1, &mmr);
22601     err = vkInvalidateMappedMemoryRanges(m_device->device(), 1, &mmr);
22604     vkUnmapMemory(m_device->device(), mem);
22608     err = vkMapMemory(m_device->device(), mem, 5 * atom_size, VK_WHOLE_SIZE, 0, (void **)&pData);
22614     err = vkFlushMappedMemoryRanges(m_device->device(), 1, &mmr);
22616     err = vkInvalidateMappedMemoryRanges(m_device->device(), 1, &mmr);
22619     vkUnmapMemory(m_device->device(), mem);
22624     err = vkMapMemory(m_device->device(), mem, 3 * atom_size, 9 * atom_size, 0, (void **)&pData);
22630     err = vkFlushMappedMemoryRanges(m_device->device(), 1, &mmr);
22632     err = vkInvalidateMappedMemoryRanges(m_device->device(), 1, &mmr);
22635     vkUnmapMemory(m_device->device(), mem);
22639     err = vkMapMemory(m_device->device(), mem, 0, VK_WHOLE_SIZE, 0, (void **)&pData);
22645     err = vkFlushMappedMemoryRanges(m_device->device(), 1, &mmr);
22649     err = vkFlushMappedMemoryRanges(m_device->device(), 1, &mmr);
22652     vkUnmapMemory(m_device->device(), mem);
22654     vkFreeMemory(m_device->device(), mem, NULL);
22666     testFence.init(*m_device, fenceInfo);
22668     VkResult result = vkResetFences(m_device->device(), 1, fences);
22689     err = vkCreateFence(m_device->device(), &fci, nullptr, &fence);
22694     err = vkCreateSemaphore(m_device->device(), &sci, nullptr, &s1);
22696     err = vkCreateSemaphore(m_device->device(), &sci, nullptr, &s2);
22701     err = vkQueueSubmit(m_device->m_queue, 1, &si, fence);
22706     err = vkQueueSubmit(m_device->m_queue, 1, &si, VK_NULL_HANDLE);
22710     err = vkWaitForFences(m_device->device(), 1, &fence, VK_TRUE, UINT64_MAX);
22715     vkDestroySemaphore(m_device->device(), s1, nullptr);
22720     vkDeviceWaitIdle(m_device->device());
22721     vkDestroySemaphore(m_device->device(), s2, nullptr);
22722     vkDestroyFence(m_device->device(), fence, nullptr);
22734     err = vkCreateFence(m_device->device(), &fci1, nullptr, &f1);
22740     err = vkCreateFence(m_device->device(), &fci2, nullptr, &f2);
22745     err = vkQueueSubmit(m_device->m_queue, 1, &si, f2);
22749     vkWaitForFences(m_device->device(), 2, fences, VK_TRUE, UINT64_MAX);
22752     vkDestroyFence(m_device->device(), f1, nullptr);
22753     vkDestroyFence(m_device->device(), f2, nullptr);
22780     VkImageObj image(m_device);
22795     vkCreateImageView(m_device->device(), &ivci, NULL, &imageView);
22797     vkDestroyImageView(m_device
22807     VkImageObj image(m_device);
22821     vkCreateImageView(m_device->device(), &ivci, NULL, &imageView);
22823     vkDestroyImageView(m_device->device(), imageView, NULL);
22832     auto index = m_device->graphics_queue_node_index_;
22833     if (!(m_device->queue_props[index].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT)) return;
22834     if (!m_device->phy().features().sparseBinding) return;
22853     VkResult err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
22864     vkGetImageMemoryRequirements(m_device->device(), image, &memory_reqs);
22870         vkDestroyImage(m_device->device(), image, nullptr);
22873         err = vkCreateImage(m_device->device(), &image_create_info, nullptr, &image);
22875         vkGetImageMemoryRequirements(m_device->device(), image, &memory_reqs);
22880     pass = m_device->phy().set_memory_type(memory_reqs.memoryTypeBits, &memory_info, 0);
22882     err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &memory_one);
22884     err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &memory_two);
22909     vkQueueBindSparse(m_device->m_queue, 1, &bindSparseInfo, fence);
22910     vkQueueWaitIdle(m_device->m_queue);
22911     vkDestroyImage(m_device->device(), image, NULL);
22912     vkFreeMemory(m_device->device(), memory_one, NULL);
22913     vkFreeMemory(m_device->device(), memory_two, NULL);
22944     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
22948     VkImageObj image(m_device);
22964     err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
22969     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
22986     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
22987     vkDestroyRenderPass(m_device->device(), rp, nullptr);
22988     vkDestroyImageView(m_device->device(), view, nullptr);
23018     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
23022     VkImageObj image(m_device);
23030     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
23038     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
23040     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
23048     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &command_buffer);
23060     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
23061     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
23062     vkDestroyRenderPass(m_device->device(), rp, nullptr);
23100     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
23104     VkImageObj image(m_device);
23112     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
23141     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
23142 m_device->device(), rp, nullptr);
23185     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
23188     VkImageObj image(m_device);
23206     err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
23211     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
23239     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
23240     vkDestroyRenderPass(m_device->device(), rp, nullptr);
23241     vkDestroyImageView(m_device->device(), view, nullptr);
23260     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
23266     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
23278     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
23279     vkDestroyRenderPass(m_device->device(), rp, nullptr);
23301     m_depthStencil->Init(m_device, 100, 100, depth_stencil_fmt,
23373     result = vkCreateFence(m_device->device(), &fence_ci, nullptr, &fence);
23382     VkImageObj destImage(m_device);
23399     vkWaitForFences(m_device->device(), 1, &fence, VK_TRUE, UINT64_MAX);
23400     VkCommandBufferObj cmdbuf(m_device, m_commandPool);
23445     vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
23448     vkQueueWaitIdle(m_device->m_queue);
23449     vkDestroyFence(m_device->device(), fence, nullptr);
23450     vkDestroyRenderPass(m_device->device(), rp, nullptr);
23451     vkDestroyFramebuffer(m_device->device(), fb, nullptr);
23484         VkImageObj img_color(m_device);
23488         VkImageObj img_ds1(m_device);
23492         VkImageObj img_ds2(m_device);
23496         VkImageObj img_xfer_src(m_device);
23500         VkImageObj img_xfer_dst(m_device);
23504         VkImageObj img_sampled(m_device);
23508         VkImageObj img_input(m_device);
23565     vkCreateEvent(m_device->device(), &event_create_info, nullptr, &event);
23570     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
23572     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
23580     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &command_buffer);
23583     vkGetDeviceQueue(m_device->device(), m_device->graphics_queue_node_index_, 0, &queue);
23604     { vkSetEvent(m_device->device(), event); }
23608     vkDestroyEvent(m_device->device(), event, nullptr);
23609     vkFreeCommandBuffers(m_device->device(), command_pool, 1, &command_buffer);
23610     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
23619     if ((m_device->queue_props.empty()) || (m_device->queue_props[0].queueCount < 2)) return;
23628     vkCreateQueryPool(m_device->device(), &query_pool_create_info, nullptr, &query_pool);
23630     VkCommandPoolObj command_pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
23631     VkCommandBufferObj primary_buffer(m_device, &command_pool);
23632     VkCommandBufferObj secondary_buffer(m_device, &command_pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
23635     vkGetDeviceQueue(m_device->device(), m_device->graphics_queue_node_index_, 1, &queue);
23647     err = vkCreateBuffer(m_device->device(), &buff_create_info, NULL, &buffer);
23651     vkGetBufferMemoryRequirements(m_device->device(), buffer, &memReqs);
23657     bool pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &mem_alloc, 0);
23659         vkDestroyBuffer(m_device->device(), buffer, NULL);
23664     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
23666     err = vkBindBufferMemory(m_device->device(), buffer, mem, 0);
23696     vkDestroyQueryPool(m_device->device(), query_pool, nullptr);
23697     vkDestroyBuffer(m_device->device(), buffer, NULL);
23698     vkFreeMemory(m_device->device(), mem, NULL);
23708     if ((m_device->queue_props.empty()) || (m_device->queue_props[0].queueCount < 2)) return;
23717     vkCreateQueryPool(m_device->device(), &query_pool_create_info, nullptr, &query_pool);
23722     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
23724     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
23732     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, command_buffer);
23735     vkGetDeviceQueue(m_device->device(), m_device->graphics_queue_node_index_, 1, &queue);
23747     err = vkCreateBuffer(m_device->device(), &buff_create_info, NULL, &buffer);
23751     vkGetBufferMemoryRequirements(m_device->device(), buffer, &memReqs);
23757     bool pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &mem_alloc, 0);
23759         vkDestroyBuffer(m_device->device(), buffer, NULL);
23764     err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
23766     err = vkBindBufferMemory(m_device->device(), buffer, mem, 0);
23797     vkDestroyQueryPool(m_device->device(), query_pool, nullptr);
23798     vkFreeCommandBuffers(m_device->device(), command_pool, 2, command_buffer);
23799     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
23800     vkDestroyBuffer(m_device->device(), buffer, NULL);
23801     vkFreeMemory(m_device->device(), mem, NULL);
23813     vkCreateEvent(m_device->device(), &event_create_info, nullptr, &event);
23818     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
23820     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
23828     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &command_buffer);
23831     vkGetDeviceQueue(m_device->device(), m_device->graphics_queue_node_index_, 0, &queue);
23852         vkSetEvent(m_device->device(), event);
23858     vkDestroyEvent(m_device->device(), event, nullptr);
23859     vkFreeCommandBuffers(m_device->device(), command_pool, 1, &command_buffer);
23860     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
23872     vkGetDeviceQueue(m_device->device(), m_device->graphics_queue_node_index_, 0, &queue);
23882     cmd_pool_ci.queueFamilyIndex = m_device->graphics_queue_node_index_;
23884     VkResult err = vkCreateCommandPool(m_device->device(), &cmd_pool_ci, nullptr, &cmd_pool);
23899         err = vkAllocateCommandBuffers(m_device->device(), &cmd_buf_info, &cmd_buffers[i]);
23901         err = vkCreateFence(m_device->device(), &fence_ci, nullptr, &fences[i]);
23923             err = vkWaitForFences(m_device->device(), 1, &fences[obj], VK_TRUE, UINT64_MAX);
23925             err = vkResetFences(m_device->device(), 1, &fences[obj]);
23930     vkDestroyCommandPool(m_device->device(), cmd_pool, NULL);
23932         vkDestroyFence(m_device->device(), fences[i], nullptr);
23941     if ((m_device->queue_props.empty()) || (m_device->queue_props[0].queueCount < 2)) return;
23948     vkCreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore);
23953     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
23955     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
23963     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, command_buffer);
23966     vkGetDeviceQueue(m_device->device(), m_device->graphics_queue_node_index_, 1, &queue);
24019         vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
24022     vkQueueWaitIdle(m_device->m_queue);
24024     vkDestroySemaphore(m_device->device(), semaphore, nullptr);
24025     vkFreeCommandBuffers(m_device->device(), command_pool, 2, &command_buffer[0]);
24026     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
24038     if ((m_device->queue_props.empty()) || (m_device->queue_props[0].queueCount < 2)) return;
24045     vkCreateFence(m_device->device(), &fence_create_info, nullptr, &fence);
24050     vkCreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore);
24055     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
24057     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
24065     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, command_buffer);
24068     vkGetDeviceQueue(m_device->device(), m_device->graphics_queue_node_index_, 1, &queue);
24121         vkQueueSubmit(m_device->m_queue, 1, &submit_info, fence);
24124     vkQueueWaitIdle(m_device->m_queue);
24126     vkDestroyFence(m_device->device(), fence, nullptr);
24127     vkDestroySemaphore(m_device->device(), semaphore, nullptr);
24128     vkFreeCommandBuffers(m_device->device(), command_pool, 2, &command_buffer[0]);
24129     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
24141     if ((m_device->queue_props.empty()) || (m_device->queue_props[0].queueCount < 2)) return;
24148     vkCreateFence(m_device->device(), &fence_create_info, nullptr, &fence);
24153     vkCreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore);
24158     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
24160     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
24168     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, command_buffer);
24171     vkGetDeviceQueue(m_device->device(), m_device->graphics_queue_node_index_, 1, &queue);
24224         vkQueueSubmit(m_device->m_queue, 1, &submit_info, fence);
24227     vkWaitForFences(m_device->device(), 1, &fence, VK_TRUE, UINT64_MAX);
24228     vkWaitForFences(m_device->device(), 1, &fence, VK_TRUE, UINT64_MAX);
24230     vkDestroyFence(m_device->device(), fence, nullptr);
24231     vkDestroySemaphore(m_device->device(), semaphore, nullptr);
24232     vkFreeCommandBuffers(m_device->device(), command_pool, 2, &command_buffer[0]);
24233     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
24240     if ((m_device->queue_props.empty()) || (m_device->queue_props[0].queueCount < 2)) {
24249     VkQueue q0 = m_device->m_queue;
24251     vkGetDeviceQueue(m_device->device(), m_device->graphics_queue_node_index_, 1, &q1);
24258     err = vkCreateCommandPool(m_device->device(), &cpci, nullptr, &pool);
24263     err = vkAllocateCommandBuffers(m_device->device(), &cbai, &cb);
24274     err = vkCreateSemaphore(m_device->device(), &sci, nullptr, &s);
24295     vkFreeCommandBuffers(m_device->device(), pool, 1, &cb);
24300     vkDeviceWaitIdle(m_device->device());
24301     vkDestroyCommandPool(m_device->device(), pool, nullptr);
24302     vkDestroySemaphore(m_device->device(), s, nullptr);
24312     if ((m_device->queue_props.empty()) || (m_device->queue_props[0].queueCount < 2)) return;
24319     vkCreateFence(m_device->device(), &fence_create_info, nullptr, &fence);
24324     vkCreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore);
24329     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
24331     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
24339     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, command_buffer);
24342     vkGetDeviceQueue(m_device->device(), m_device->graphics_queue_node_index_, 1, &queue);
24395         vkQueueSubmit(m_device->m_queue, 1, &submit_info, fence);
24398     vkWaitForFences(m_device->device(), 1, &fence, VK_TRUE, UINT64_MAX);
24400     vkDestroyFence(m_device->device(), fence, nullptr);
24401     vkDestroySemaphore(m_device->device(), semaphore, nullptr);
24402     vkFreeCommandBuffers(m_device->device(), command_pool, 2, &command_buffer[0]);
24403     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
24420     vkCreateFence(m_device->device(), &fence_create_info, nullptr, &fence);
24425     vkCreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore);
24430     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
24432     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
24440     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, command_buffer);
24482         vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
24493         vkQueueSubmit(m_device->m_queue, 1, &submit_info, fence);
24496     vkWaitForFences(m_device->device(), 1, &fence, VK_TRUE, UINT64_MAX);
24498     vkDestroyFence(m_device->device(), fence, nullptr);
24499     vkDestroySemaphore(m_device->device(), semaphore, nullptr);
24500     vkFreeCommandBuffers(m_device->device(), command_pool, 2, &command_buffer[0]);
24501     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
24518     vkCreateFence(m_device->device(), &fence_create_info, nullptr, &fence);
24523     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
24525     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
24533     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, command_buffer);
24575         vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
24586         vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
24589     vkQueueSubmit(m_device->m_queue, 0, NULL, fence);
24591     VkResult err = vkWaitForFences(m_device->device(), 1, &fence, VK_TRUE, UINT64_MAX);
24594     vkDestroyFence(m_device->device(), fence, nullptr);
24595     vkFreeCommandBuffers(m_device->device(), command_pool, 2, &command_buffer[0]);
24596     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
24613     vkCreateFence(m_device->device(), &fence_create_info, nullptr, &fence);
24618     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
24620     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
24628     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, command_buffer);
24670         vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
24681         vkQueueSubmit(m_device->m_queue, 1, &submit_info, fence);
24684     vkWaitForFences(m_device->device(), 1, &fence, VK_TRUE, UINT64_MAX);
24686     vkDestroyFence(m_device->device(), fence, nullptr);
24687     vkFreeCommandBuffers(m_device->device(), command_pool, 2, &command_buffer[0]);
24688     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
24704     vkCreateFence(m_device->device(), &fence_create_info, nullptr, &fence);
24709     vkCreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore);
24714     pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
24716     vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool);
24724     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, command_buffer);
24782         vkQueueSubmit(m_device->m_queue, 2, &submit_info[0], fence);
24785     vkWaitForFences(m_device->device(), 1, &fence, VK_TRUE, UINT64_MAX);
24787     vkDestroyFence(m_device->device(), fence, nullptr);
24788     vkFreeCommandBuffers(m_device->device(), command_pool, 2, &command_buffer[0]);
24789     vkDestroyCommandPool(m_device->device(), command_pool, NULL);
24790     vkDestroySemaphore(m_device->device(), semaphore, nullptr);
24856     vkCreateRenderPass(m_device->device(), &rpci, NULL, &rp);
24859     vkDestroyRenderPass(m_device->device(), rp, NULL);
24902     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
24905     VkImageObj image(m_device);
24921     err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
24926     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
24938     vkDestroyImageView(m_device->device(), view, NULL);
24939     vkDestroyRenderPass(m_device->device(), rp, NULL);
24940     vkDestroyFramebuffer(m_device->device(), fb, NULL);
24976     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
24977     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
24979     VkPipelineObj pipe(m_device);
24987     VkDescriptorSetObj descriptorSet(m_device);
25029     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
25030     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
25032     VkPipelineObj pipe(m_device);
25040     VkDescriptorSetObj descriptorSet(m_device);
25087     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
25088     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
25090     VkPipelineObj pipe(m_device);
25098     VkDescriptorSetObj descriptorSet(m_device);
25126     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
25127     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
25129     VkPipelineObj pipe(m_device);
25134     VkDescriptorSetObj descriptorSet(m_device);
25174     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
25175     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
25177     VkPipelineObj pipe(m_device);
25182     VkDescriptorSetObj descriptorSet(m_device);
25200     if (!m_device->phy().features().tessellationShader) {
25232     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
25233     VkShaderObj tcs(m_device, tcsSource, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, this);
25234     VkShaderObj tes(m_device, tesSource, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, this);
25235     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
25242     VkPipelineObj pipe(m_device);
25251     VkDescriptorSetObj descriptorSet(m_device);
25269     if (!m_device->phy().features().geometryShader) {
25296     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
25297     VkShaderObj gs(m_device, gsSource, VK_SHADER_STAGE_GEOMETRY_BIT, this);
25298     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
25300     VkPipelineObj pipe(m_device);
25306     VkDescriptorSetObj descriptorSet(m_device);
25327     if (!m_device->phy().features().shaderFloat64) {
25377     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
25378     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
25380     VkPipelineObj pipe(m_device);
25388     VkDescriptorSetObj descriptorSet(m_device);
25418     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
25419     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
25421     VkPipelineObj pipe(m_device);
25428     const VkDescriptorSetLayoutObj dsl(m_device, {dslb});
25429     const VkPipelineLayoutObj pl(m_device, {&dsl});
25451     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
25459     vkDestroyRenderPass(m_device->device(), rp, nullptr);
25480     VkShaderObj cs(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
25482     VkDescriptorSetObj descriptorSet(m_device);
25495     VkResult err = vkCreateComputePipelines(m_device->device(), VK_NULL_HANDLE, 1, &cpci, nullptr, &pipe);
25500         vkDestroyPipeline(m_device->device(), pipe, nullptr);
25517     const VkDescriptorSetLayoutObj dsl(m_device, bindings);
25518     const VkPipelineLayoutObj pl(m_device, {&dsl});
25530     VkShaderObj cs(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
25542     VkResult err = vkCreateComputePipelines(m_device->device(), VK_NULL_HANDLE, 1, &cpci, nullptr, &pipe);
25547         vkDestroyPipeline(m_device->device(), pipe, nullptr);
25564     const VkDescriptorSetLayoutObj dsl(m_device, bindings);
25565     const VkPipelineLayoutObj pl(m_device, {&dsl});
25577     VkShaderObj cs(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
25589     VkResult err = vkCreateComputePipelines(m_device->device(), VK_NULL_HANDLE, 1, &cpci, nullptr, &pipe);
25594         vkDestroyPipeline(m_device->device(), pipe, nullptr);
25611     const VkDescriptorSetLayoutObj dsl(m_device, bindings);
25612     const VkPipelineLayoutObj pl(m_device, {&dsl});
25624     VkShaderObj cs(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
25636     VkResult err = vkCreateComputePipelines(m_device->device(), VK_NULL_HANDLE, 1, &cpci, nullptr, &pipe);
25641         vkDestroyPipeline(m_device->device(), pipe, nullptr);
25691         const VkResult err = vkCreateDescriptorSetLayout(m_device->device(), &dslci, nullptr, &dsl);
25693         vkDestroyDescriptorSetLayout(m_device->device(), dsl, nullptr);
25714             const VkResult err = vkCreateDescriptorSetLayout(m_device->device(), &dslci, nullptr, &dsl);
25716             vkDestroyDescriptorSetLayout(m_device->device(), dsl, nullptr);
25736     VkCommandBufferObj cmd_buf(m_device, m_commandPool);
25780     vkCreateBuffer(m_device->device(), &buffer_create_info, NULL, &buffer);
25814     VkResult err = vkCreateBuffer(m_device->device(), &buffer_create_info, NULL, &buffer);
25818     vkGetBufferMemoryRequirements(m_device->device(), buffer, &memory_reqs);
25832     pass = m_device->phy().set_memory_type(memory_reqs.memoryTypeBits, &memory_info, 0);
25836     err = vkAllocateMemory(m_device->device(), &memory_info, NULL, &buffer_memory);
25839     err = vkBindBufferMemory(m_device->device(), buffer, buffer_memory, 0);
25842     vkDestroyBuffer(m_device->device(), buffer, NULL);
25843     vkFreeMemory(m_device->device(), buffer_memory, NULL);
25855     auto features = m_device->phy().features();
25903         err = vkCreateSemaphore(m_device->device(), &sci, nullptr, &semaphore);
25917         err = vkQueueSubmit(m_device->m_queue, 1, &si, VK_NULL_HANDLE);
25923     err = vkCreateFence(m_device->device(), &fci, nullptr, &fence);
25926     err = vkQueueSubmit(m_device->m_queue, 1, &si, fence);
25929     vkWaitForFences(m_device->device(), 1, &fence, VK_TRUE, UINT64_MAX);
25931     for (auto semaphore : semaphores) vkDestroySemaphore(m_device->device(), semaphore, nullptr);
25933     vkDestroyFence(m_device->device(), fence, nullptr);
25989     err = vkCreateSemaphore(m_device->device(), &sci, nullptr, &export_semaphore);
25995     err = vkCreateSemaphore(m_device->device(), &sci, nullptr, &import_semaphore);
26004         (PFN_vkGetSemaphoreWin32HandleKHR)vkGetDeviceProcAddr(m_device->device(), "vkGetSemaphoreWin32HandleKHR");
26005     err = vkGetSemaphoreWin32HandleKHR(m_device->device(), &ghi, &handle);
26012         (PFN_vkImportSemaphoreWin32HandleKHR)vkGetDeviceProcAddr(m_device->device(), "vkImportSemaphoreWin32HandleKHR");
26013     err = vkImportSemaphoreWin32HandleKHR(m_device->device(), &ihi);
26019     auto vkGetSemaphoreFdKHR = (PFN_vkGetSemaphoreFdKHR)vkGetDeviceProcAddr(m_device->device(), "vkGetSemaphoreFdKHR");
26020     err = vkGetSemaphoreFdKHR(m_device->device(), &ghi, &fd);
26026     auto vkImportSemaphoreFdKHR = (PFN_vkImportSemaphoreFdKHR)vkGetDeviceProcAddr(m_device->device(), "vkImportSemaphoreFdKHR");
26027     err = vkImportSemaphoreFdKHR(m_device->device(), &ihi);
26039     err = vkQueueSubmit(m_device->m_queue, 4, si, VK_NULL_HANDLE);
26042     if (m_device->phy().features().sparseBinding) {
26050         err = vkQueueBindSparse(m_device->m_queue, 4, bi, VK_NULL_HANDLE);
26055     err = vkQueueWaitIdle(m_device->m_queue);
26057     vkDestroySemaphore(m_device->device(), export_semaphore, nullptr);
26058     vkDestroySemaphore(m_device->device(), import_semaphore, nullptr);
26112         err = vkCreateFence(m_device->device(), &fci, nullptr, &export_fence);
26120         err = vkCreateFence(m_device->device(), &fci, nullptr, &import_fence);
26130             (PFN_vkGetFenceWin32HandleKHR)vkGetDeviceProcAddr(m_device->device(), "vkGetFenceWin32HandleKHR");
26131         err = vkGetFenceWin32HandleKHR(m_device->device(), &ghi, &handle);
26140             (PFN_vkImportFenceWin32HandleKHR)vkGetDeviceProcAddr(m_device->device(), "vkImportFenceWin32HandleKHR");
26141         err = vkImportFenceWin32HandleKHR(m_device->device(), &ifi);
26149         auto vkGetFenceFdKHR = (PFN_vkGetFenceFdKHR)vkGetDeviceProcAddr(m_device->device(), "vkGetFenceFdKHR");
26150         err = vkGetFenceFdKHR(m_device->device(), &gfi, &fd);
26157         auto vkImportFenceFdKHR = (PFN_vkImportFenceFdKHR)vkGetDeviceProcAddr(m_device->device(), "vkImportFenceFdKHR");
26158         err = vkImportFenceFdKHR(m_device->device(), &ifi);
26164     vkQueueSubmit(m_device->m_queue, 0, nullptr, export_fence);
26165     vkWaitForFences(m_device->device(), 1, &import_fence, VK_TRUE, 1000000000);
26166     vkResetFences(m_device->device(), 1, &import_fence);
26167     vkQueueSubmit(m_device->m_queue, 0, nullptr, export_fence);
26168     vkWaitForFences(m_device->device(), 1, &import_fence, VK_TRUE, 1000000000);
26169     vkResetFences(m_device->device(), 1, &import_fence);
26172     vkQueueSubmit(m_device->m_queue, 0, nullptr, import_fence);
26173     vkWaitForFences(m_device->device(), 1, &export_fence, VK_TRUE, 1000000000);
26174     vkResetFences(m_device->device(), 1, &export_fence);
26175     vkQueueSubmit(m_device->m_queue, 0, nullptr, import_fence);
26176     vkWaitForFences(m_device
26177     vkResetFences(m_device->device(), 1, &export_fence);
26180     err = vkQueueWaitIdle(m_device->m_queue);
26182     vkDestroyFence(m_device->device(), export_fence, nullptr);
26183     vkDestroyFence(m_device->device(), import_fence, nullptr);
26208     data.device = m_device->device();
26216         vkDestroyFence(m_device->device(), VK_NULL_HANDLE, NULL);
26231     VkImageObj image(m_device);
26271     VkImageObj image(m_device);
26308     m_depthStencil->Init(m_device, static_cast<int32_t>(m_width), static_cast<int32_t>(m_height), m_depth_stencil_fmt);
26317     VkShaderObj vs(m_device, "#version 450\nvoid main(){gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}\n", VK_SHADER_STAGE_VERTEX_BIT,
26366         VkResult err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_create_info, nullptr, &pipeline_layout);
26400         vkCreateGraphicsPipelines(m_device->handle(), VK_NULL_HANDLE, 1, &graphics_pipeline_create_info, nullptr, &pipeline);
26404         vkDestroyPipeline(m_device->handle(), pipeline, nullptr);
26455             VkResult err = vkCreateRenderPass(m_device->handle(), &render_pass_create_info, nullptr, &render_pass);
26481         vkCreateGraphicsPipelines(m_device->handle(), VK_NULL_HANDLE, 1, &graphics_pipeline_create_info, nullptr, &pipeline);
26485         vkDestroyPipeline(m_device->handle(), pipeline, nullptr);
26486         vkDestroyRenderPass(m_device->handle(), render_pass, nullptr);
26553         vkCreateGraphicsPipelines(m_device->handle(), VK_NULL_HANDLE, 1, &graphics_pipeline_create_info, nullptr, &pipeline);
26557         vkDestroyPipeline(m_device->handle(), pipeline, nullptr);
26560     vkDestroyPipelineLayout(m_device->handle(), pipeline_layout, nullptr);
26634     buffer_export.init_no_mem(*m_device, buffer_info);
26636     buffer_import.init_no_mem(*m_device, buffer_info);
26639     auto alloc_info = vk_testing::DeviceMemory::get_resource_alloc_info(*m_device, buffer_export.memory_requirements(), mem_flags);
26654     memory_export.init(*m_device, alloc_info);
26666     ASSERT_VK_SUCCESS(vkGetMemoryWin32HandleKHR(m_device->device(), &mghi, &handle));
26676     ASSERT_VK_SUCCESS(vkGetMemoryFdKHR(m_device->device(), &mgfi, &fd));
26682     alloc_info = vk_testing::DeviceMemory::get_resource_alloc_info(*m_device, buffer_import.memory_requirements(), mem_flags);
26685     memory_import.init(*m_device, alloc_info);
26693     buffer_input.init_as_src_and_dst(*m_device, buffer_size, mem_prop);
26700     buffer_output.init_as_src_and_dst(*m_device, buffer_size, mem_prop);
26808     VkRenderpassObj render_pass(m_device);
26810     const VkPipelineLayoutObj pipeline_layout(m_device);
26812     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
26813     VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
26821     VkPipelineObj pipe(m_device);
26858     // We're not creating a valid m_device, but the phy wrapper is useful
26942     buffer.init_no_mem(*m_device,
26947         vkGetDeviceProcAddr(m_device->device(), "vkGetBufferMemoryRequirements2KHR"));
26952     vkGetBufferMemoryRequirements2KHR(m_device->device(), &buffer_info, &buffer_reqs);
26956     buffer_memory.init(*m_device, vk_testing::DeviceMemory::get_resource_alloc_info(*m_device, buffer_reqs.memoryRequirements, 0));
26957     vkBindBufferMemory(m_device->device(), buffer.handle(), buffer_memory.handle(), 0);
26968     image.init_no_mem(*m_device, image_ci);
26972         vkGetDeviceProcAddr(m_device->device(), "vkGetImageMemoryRequirements2KHR"));
26977     vkGetImageMemoryRequirements2KHR(m_device->device(), &image_info, &image_reqs);
26981     image_memory.init(*m_device, vk_testing::DeviceMemory::get_resource_alloc_info(*m_device, image_reqs.memoryRequirements, 0));
26982     vkBindImageMemory(m_device->device(), image.handle(), image_memory.handle(), 0);
27026     buffer.init_no_mem(*m_device, vk_testing::Buffer::create_info(1024, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
27030     buffer_memory.init(*m_device, vk_testing::DeviceMemory::get_resource_alloc_info(*m_device, buffer.memory_requirements(), 0));
27034         reinterpret_cast<PFN_vkBindBufferMemory2KHR>(vkGetDeviceProcAddr(m_device->device(), "vkBindBufferMemory2KHR"));
27038     vkBindBufferMemory2KHR(m_device->device(), 1, &buffer_bind_info);
27049     image.init_no_mem(*m_device, image_ci);
27053     image_memory.init(*m_device, vk_testing::DeviceMemory::get_resource_alloc_info(*m_device, image.memory_requirements(), 0));
27057         reinterpret_cast<PFN_vkBindImageMemory2KHR>(vkGetDeviceProcAddr(m_device->device(), "vkBindImageMemory2KHR"));
27061     vkBindImageMemory2KHR(m_device->device(), 1, &image_bind_info);
OpenGrok
