Attachment 139576 Details for Bug 106528 – Test case

Test case

d24.c (text/x-csrc), 55.79 KB, created by Józef Kucia on 2018-05-15 14:05:38 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Józef Kucia

Created: 2018-05-15 14:05:38 UTC

Size: 55.79 KB

patch

obsolete

>/*
> * gcc -lvulkan d24.c -o d24
> */
>#include <assert.h>
>#include <stdbool.h>
>#include <stdio.h>
>#include <stdlib.h>
>#include <string.h>
>
>#define VK_USE_PLATFORM_XCB_KHR
>
>#include <vulkan/vulkan.h>
>
>#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x))
>
>static const char * const instance_extensions[] =
>{
>    VK_KHR_SURFACE_EXTENSION_NAME,
>    VK_KHR_XCB_SURFACE_EXTENSION_NAME,
>};
>
>static const char * const device_extensions[] =
>{
>    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
>};
>
>static VkInstance create_instance(void)
>{
>    VkApplicationInfo application_info;
>    VkInstanceCreateInfo instance_info;
>    VkInstance instance;
>    VkResult vr;
>
>    application_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
>    application_info.pNext = NULL;
>    application_info.pApplicationName = "vk-dump-shader";
>    application_info.applicationVersion = 0;
>    application_info.pEngineName = NULL;
>    application_info.engineVersion = 0;
>    application_info.apiVersion = VK_API_VERSION_1_0;
>
>    instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
>    instance_info.pNext = NULL;
>    instance_info.flags = 0;
>    instance_info.pApplicationInfo = &application_info;
>    instance_info.enabledLayerCount = 0;
>    instance_info.ppEnabledLayerNames = NULL;
>    instance_info.enabledExtensionCount = ARRAY_SIZE(instance_extensions);
>    instance_info.ppEnabledExtensionNames = instance_extensions;
>
>    if ((vr = vkCreateInstance(&instance_info, NULL, &instance)))
>    {
>        fprintf(stderr, "Failed to create Vulkan instance, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return instance;
>}
>
>static VkPhysicalDevice select_physical_device(VkInstance instance)
>{
>    VkPhysicalDevice *physical_devices, selected_device;
>    uint32_t count;
>    unsigned int i;
>    VkResult vr;
>
>    count = 0;
>    if ((vr = vkEnumeratePhysicalDevices(instance, &count, NULL)) < 0)
>    {
>        fprintf(stderr, "Failed to enumerate physical devices, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    if (!count)
>    {
>        fprintf(stderr, "No physical device available.\n");
>        return VK_NULL_HANDLE;
>    }
>    if (!(physical_devices = calloc(count, sizeof(*physical_devices))))
>        return VK_NULL_HANDLE;
>
>    if ((vr = vkEnumeratePhysicalDevices(instance, &count, physical_devices)) < 0)
>    {
>        fprintf(stderr, "Failed to enumerate physical devices, vr %d.\n", vr);
>        free(physical_devices);
>        return VK_NULL_HANDLE;
>    }
>
>    selected_device = physical_devices[0];
>    free(physical_devices);
>    return selected_device;
>}
>
>static VkDevice create_device(VkInstance instance, VkPhysicalDevice physical_device)
>{
>    VkQueueFamilyProperties *queue_properties;
>    VkPhysicalDeviceFeatures device_features;
>    VkDeviceQueueCreateInfo *queue_info;
>    VkDeviceCreateInfo device_info;
>    uint32_t queue_family_count;
>    VkDevice device;
>    unsigned int i;
>    VkResult vr;
>
>    vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, NULL);
>    if (!(queue_properties = calloc(queue_family_count, sizeof(*queue_properties))))
>        return VK_NULL_HANDLE;
>    vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, queue_properties);
>
>    if (!(queue_info = calloc(queue_family_count, sizeof(*queue_info))))
>    {
>        free(queue_properties);
>        return VK_NULL_HANDLE;
>    }
>
>    for (i = 0; i < queue_family_count; ++i)
>    {
>        static float priorities[] = {1.0f};
>
>        queue_info[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
>        queue_info[i].pNext = NULL;
>        queue_info[i].flags = 0;
>        queue_info[i].queueFamilyIndex = i;
>        queue_info[i].queueCount = 1;
>        queue_info[i].pQueuePriorities = priorities;
>    }
>    free(queue_properties);
>
>    vkGetPhysicalDeviceFeatures(physical_device, &device_features);
>
>    device_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
>    device_info.pNext = NULL;
>    device_info.flags = 0;
>    device_info.queueCreateInfoCount = queue_family_count;
>    device_info.pQueueCreateInfos = queue_info;
>    device_info.enabledLayerCount = 0;
>    device_info.ppEnabledLayerNames = NULL;
>    device_info.enabledExtensionCount = ARRAY_SIZE(device_extensions);
>    device_info.ppEnabledExtensionNames = device_extensions;
>    device_info.pEnabledFeatures = &device_features;
>
>    vr = vkCreateDevice(physical_device, &device_info, NULL, &device);
>    free(queue_info);
>    if (vr < 0)
>    {
>        fprintf(stderr, "Failed to create Vulkan device, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return device;
>}
>
>static VkShaderModule create_shader_module(VkDevice device, size_t size, const void *code)
>{
>    VkShaderModuleCreateInfo create_info;
>    VkShaderModule module;
>    VkResult vr;
>
>    memset(&create_info, 0, sizeof(create_info));
>    create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
>    create_info.codeSize = size;
>    create_info.pCode = code;
>    if ((vr = vkCreateShaderModule(device, &create_info, NULL, &module)) < 0)
>    {
>        fprintf(stderr, "Failed to create shader module, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return module;
>}
>
>static VkPipeline create_graphics_pipeline(VkDevice device, VkPipelineLayout layout,
>        VkShaderModule vs, VkShaderModule fs, VkRenderPass render_pass)
>{
>    VkPipelineRasterizationStateCreateInfo rasterization_state;
>    VkPipelineMultisampleStateCreateInfo multisample_state;
>    VkPipelineInputAssemblyStateCreateInfo input_assembly;
>    VkPipelineColorBlendAttachmentState blend_attachment;
>    VkPipelineShaderStageCreateInfo stage_create_info[2];
>    VkPipelineVertexInputStateCreateInfo vertex_input;
>    VkPipelineViewportStateCreateInfo viewport_state;
>    VkPipelineColorBlendStateCreateInfo blend_state;
>    VkGraphicsPipelineCreateInfo create_info;
>    VkViewport viewports[1];
>    VkRect2D scissors[1];
>    VkPipeline pipeline;
>    VkResult vr;
>
>    memset(stage_create_info, 0, sizeof(stage_create_info));
>    stage_create_info[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
>    stage_create_info[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
>    stage_create_info[0].module = vs;
>    stage_create_info[0].pName = "main";
>    stage_create_info[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
>    stage_create_info[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
>    stage_create_info[1].module = fs;
>    stage_create_info[1].pName = "main";
>
>    memset(&vertex_input, 0, sizeof(vertex_input));
>    vertex_input.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
>
>    memset(&input_assembly, 0, sizeof(input_assembly));
>    input_assembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
>    input_assembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
>
>    viewports[0].x = 0.0f;
>    viewports[0].y = 0.0f;
>    viewports[0].width = 32.0f;
>    viewports[0].height = 32.0f;
>    viewports[0].minDepth = 0.0f;
>    viewports[0].maxDepth = 1.0f;
>    scissors[0].offset.x = 0;
>    scissors[0].offset.y = 0;
>    scissors[0].extent.width = 32;
>    scissors[0].extent.height = 32;
>    memset(&viewport_state, 0, sizeof(viewport_state));
>    viewport_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
>    viewport_state.viewportCount = 1;
>    viewport_state.pViewports = viewports;
>    viewport_state.scissorCount = 1;
>    viewport_state.pScissors = scissors;
>
>    memset(&rasterization_state, 0, sizeof(rasterization_state));
>    rasterization_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
>    rasterization_state.polygonMode = VK_POLYGON_MODE_FILL;
>    rasterization_state.cullMode = VK_CULL_MODE_NONE;
>    rasterization_state.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
>    rasterization_state.lineWidth = 1.0f;
>
>    memset(&multisample_state, 0, sizeof(multisample_state));
>    multisample_state.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
>    multisample_state.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
>
>    memset(&blend_attachment, 0, sizeof(blend_attachment));
>    blend_attachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT
>            | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
>    memset(&blend_state, 0, sizeof(blend_state));
>    blend_state.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
>    blend_state.attachmentCount = 1;
>    blend_state.pAttachments = &blend_attachment;
>
>    memset(&create_info, 0, sizeof(create_info));
>    create_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
>    create_info.stageCount = 2;
>    create_info.pStages = stage_create_info;
>    create_info.pVertexInputState = &vertex_input;
>    create_info.pInputAssemblyState = &input_assembly;
>    create_info.pViewportState = &viewport_state;
>    create_info.pRasterizationState = &rasterization_state;
>    create_info.pMultisampleState = &multisample_state;
>    create_info.pColorBlendState = &blend_state;
>    create_info.layout = layout;
>    create_info.renderPass = render_pass;
>    create_info.basePipelineIndex = -1;
>
>    if ((vr = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE,
>            1, &create_info, NULL, &pipeline)) < 0)
>    {
>        fprintf(stderr, "Failed to create pipeline, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return pipeline;
>}
>
>static VkRenderPass create_render_pass(VkDevice device)
>{
>    VkAttachmentReference attachment_ref;
>    VkAttachmentDescription attachment;
>    VkRenderPassCreateInfo pass_info;
>    VkSubpassDescription subpass;
>    VkRenderPass render_pass;
>    VkResult vr;
>
>    memset(&attachment, 0, sizeof(attachment));
>    attachment.format = VK_FORMAT_R32G32B32A32_SFLOAT;
>    attachment.samples = VK_SAMPLE_COUNT_1_BIT;
>    attachment.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
>    attachment.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
>
>    attachment_ref.attachment = 0;
>    attachment_ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
>
>    memset(&subpass, 0, sizeof(subpass));
>    subpass.flags = 0;
>    subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
>    subpass.colorAttachmentCount = 1;
>    subpass.pColorAttachments = &attachment_ref;
>
>    memset(&pass_info, 0, sizeof(pass_info));
>    pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
>    pass_info.attachmentCount = 1;
>    pass_info.pAttachments = &attachment;
>    pass_info.subpassCount = 1;
>    pass_info.pSubpasses = &subpass;
>
>    if ((vr = vkCreateRenderPass(device, &pass_info, NULL, &render_pass)) < 0)
>    {
>        fprintf(stderr, "Failed to create render pass, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return render_pass;
>}
>
>static VkDescriptorSetLayout create_descriptor_set_layout(VkDevice device)
>{
>    VkDescriptorSetLayoutCreateInfo create_info;
>    VkDescriptorSetLayoutBinding bindings[3];
>    VkDescriptorSetLayout layout;
>    unsigned int i;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.bindingCount = ARRAY_SIZE(bindings);
>    create_info.pBindings = bindings;
>
>    bindings[0].binding = 0;
>    bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
>    bindings[0].descriptorCount = 1;
>    bindings[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
>    bindings[0].pImmutableSamplers = NULL;
>    bindings[1].binding = 1;
>    bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
>    bindings[1].descriptorCount = 1;
>    bindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
>    bindings[1].pImmutableSamplers = NULL;
>    bindings[2].binding = 2;
>    bindings[2].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
>    bindings[2].descriptorCount = 1;
>    bindings[2].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
>    bindings[2].pImmutableSamplers = NULL;
>
>    if ((vr = vkCreateDescriptorSetLayout(device, &create_info, NULL, &layout) < 0))
>    {
>        fprintf(stderr, "Failed to create descriptor set, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return layout;
>}
>
>static VkDescriptorPool create_descriptor_pool(VkDevice device)
>{
>    VkDescriptorPoolCreateInfo create_info;
>    VkDescriptorPoolSize pool_sizes[4];
>    VkDescriptorPool pool;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.maxSets = 32;
>    create_info.poolSizeCount = ARRAY_SIZE(pool_sizes);
>    create_info.pPoolSizes = pool_sizes;
>
>    pool_sizes[0].type = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
>    pool_sizes[0].descriptorCount = 32;
>    pool_sizes[1].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
>    pool_sizes[1].descriptorCount = 32;
>    pool_sizes[2].type = VK_DESCRIPTOR_TYPE_SAMPLER;
>    pool_sizes[2].descriptorCount = 32;
>    pool_sizes[3].type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
>    pool_sizes[3].descriptorCount = 32;
>
>    if ((vr = vkCreateDescriptorPool(device, &create_info, NULL, &pool)) < 0)
>    {
>        fprintf(stderr, "Failed to create descriptor pool, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return pool;
>}
>
>static VkDescriptorSet allocate_descriptor_set(VkDevice device,
>        VkDescriptorPool pool, VkDescriptorSetLayout set_layout)
>{
>    VkDescriptorSetAllocateInfo allocate_info;
>    VkDescriptorSet set;
>    VkResult vr;
>
>    allocate_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
>    allocate_info.pNext = NULL;
>    allocate_info.descriptorPool = pool;
>    allocate_info.descriptorSetCount = 1;
>    allocate_info.pSetLayouts = &set_layout;
>
>    if ((vr = vkAllocateDescriptorSets(device, &allocate_info, &set)) < 0)
>    {
>        fprintf(stderr, "Failed to allocate descriptor set, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return set;
>}
>
>static VkPipelineLayout create_pipeline_layout(VkDevice device,
>        VkDescriptorSetLayout set_layout)
>{
>    VkPipelineLayoutCreateInfo create_info;
>    VkPipelineLayout layout;
>    VkResult vr;
>
>    memset(&create_info, 0, sizeof(create_info));
>    create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
>    if (set_layout)
>    {
>        create_info.setLayoutCount = 1;
>        create_info.pSetLayouts = &set_layout;
>    }
>
>    if ((vr = vkCreatePipelineLayout(device, &create_info, NULL, &layout)) < 0)
>    {
>        fprintf(stderr, "Failed to create pipeline layout, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return layout;
>}
>
>static VkCommandPool create_command_pool(VkDevice device, uint32_t queue_index)
>{
>    VkCommandPoolCreateInfo create_info;
>    VkCommandPool pool;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.queueFamilyIndex = queue_index;
>
>    if ((vr = vkCreateCommandPool(device, &create_info, NULL, &pool)) < 0)
>    {
>        fprintf(stderr, "Failed to create command pool, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return pool;
>}
>
>static VkCommandBuffer allocate_command_buffer(VkDevice device, VkCommandPool pool)
>{
>    VkCommandBufferAllocateInfo allocate_info;
>    VkCommandBuffer command_buffer;
>    VkResult vr;
>
>    allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
>    allocate_info.pNext = NULL;
>    allocate_info.commandPool = pool;
>    allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
>    allocate_info.commandBufferCount = 1;
>
>    if ((vr = vkAllocateCommandBuffers(device, &allocate_info, &command_buffer)) < 0)
>    {
>        fprintf(stderr, "Failed to allocate command buffer, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return command_buffer;
>}
>
>static void begin_command_buffer(VkCommandBuffer command_buffer)
>{
>    VkCommandBufferBeginInfo begin_info;
>    VkResult vr;
>
>    begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
>    begin_info.pNext = NULL;
>    begin_info.flags = 0;
>    begin_info.pInheritanceInfo = NULL;
>
>    if ((vr = vkBeginCommandBuffer(command_buffer, &begin_info)) < 0)
>    {
>        fprintf(stderr, "Failed to begin command buffer, vr %d.\n", vr);
>    }
>    assert(vr == VK_SUCCESS);
>}
>
>static void end_command_buffer(VkCommandBuffer command_buffer)
>{
>    VkResult vr;
>
>    if ((vr = vkEndCommandBuffer(command_buffer)) < 0)
>    {
>        fprintf(stderr, "Failed to end command buffer, vr %d.\n", vr);
>    }
>    assert(vr == VK_SUCCESS);
>}
>
>static void submit_commands(VkDevice device,
>        VkQueue queue, VkCommandBuffer command_buffer, bool wait)
>{
>    VkFenceCreateInfo create_info;
>    VkSubmitInfo submit_info;
>    VkFence fence;
>    VkResult vr;
>
>    fence = VK_NULL_HANDLE;
>    if (wait)
>    {
>        create_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
>        create_info.pNext = NULL;
>        create_info.flags = 0;
>
>        if ((vr = vkCreateFence(device, &create_info, NULL, &fence)) < 0)
>        {
>            fprintf(stderr, "Failed to create fence, vr %d.\n", vr);
>            return;
>        }
>    }
>
>    memset(&submit_info, 0, sizeof(submit_info));
>    submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
>    submit_info.pNext = NULL;
>    submit_info.commandBufferCount = 1;
>    submit_info.pCommandBuffers = &command_buffer;
>
>    if ((vr = vkQueueSubmit(queue, 1, &submit_info, fence) < 0))
>    {
>        fprintf(stderr, "Failed to submit commands, vr %d.\n", vr);
>        vkDestroyFence(device, fence, NULL);
>        return;
>    }
>
>    if ((vr = vkWaitForFences(device, 1, &fence, VK_FALSE, ~0u)) < 0)
>    {
>        fprintf(stderr, "Failed to wait for fences, vr %d.\n", vr);
>        return;
>    }
>
>    vkDestroyFence(device, fence, NULL);
>}
>
>static VkBuffer create_buffer(VkDevice device,
>        VkDeviceSize size, VkBufferUsageFlags usage)
>{
>    VkBufferCreateInfo buffer_info;
>    VkBuffer buffer;
>    VkResult vr;
>
>    buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
>    buffer_info.pNext = NULL;
>    buffer_info.flags = 0;
>    buffer_info.size = size;
>    buffer_info.usage = usage;
>    buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
>    buffer_info.queueFamilyIndexCount = 0;
>    buffer_info.pQueueFamilyIndices = 0;
>
>    if ((vr = vkCreateBuffer(device, &buffer_info, NULL, &buffer)) < 0)
>    {
>        fprintf(stderr, "Failed to create Vulkan buffer, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return buffer;
>}
>
>static unsigned int select_memory_type(VkDevice device, VkPhysicalDevice physical_device,
>        uint32_t memory_type_mask, VkMemoryPropertyFlags required_flags)
>{
>    VkPhysicalDeviceMemoryProperties memory_info;
>    unsigned int i;
>
>    vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_info);
>
>    for (i = 0; i < memory_info.memoryTypeCount; ++i)
>    {
>        if (!(memory_type_mask & (1u << i)))
>            continue;
>        if ((memory_info.memoryTypes[i].propertyFlags & required_flags) == required_flags)
>            return i;
>    }
>
>    return ~0u;
>}
>
>static VkDeviceMemory allocate_device_memory(VkDevice device, VkPhysicalDevice physical_device,
>        const VkMemoryRequirements *memory_requirements, VkMemoryPropertyFlags memory_flags)
>{
>    VkMemoryAllocateInfo allocate_info;
>    VkDeviceMemory vk_memory;
>    VkResult vr;
>
>    allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
>    allocate_info.pNext = NULL;
>    allocate_info.allocationSize = memory_requirements->size;
>    allocate_info.memoryTypeIndex = select_memory_type(device, physical_device,
>            memory_requirements->memoryTypeBits, memory_flags);
>
>    if (allocate_info.memoryTypeIndex == ~0u)
>    {
>        fprintf(stderr, "Failed to find suitable memory type (allowed types %#x).\n",
>                memory_requirements->memoryTypeBits);
>        return VK_NULL_HANDLE;
>    }
>
>    if ((vr = vkAllocateMemory(device, &allocate_info, NULL, &vk_memory)) < 0)
>    {
>        fprintf(stderr, "Failed to allocate device memory, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return vk_memory;
>}
>
>static VkDeviceMemory allocate_buffer_memory(VkDevice device, VkPhysicalDevice physical_device,
>        VkBuffer buffer, VkMemoryPropertyFlags memory_flags)
>{
>    VkMemoryRequirements memory_requirements;
>    VkDeviceMemory memory;
>    VkResult vr;
>
>    vkGetBufferMemoryRequirements(device, buffer, &memory_requirements);
>    memory = allocate_device_memory(device, physical_device, &memory_requirements, memory_flags);
>    assert(memory != VK_NULL_HANDLE);
>
>    if ((vr = vkBindBufferMemory(device, buffer, memory, 0)) < 0)
>    {
>        fprintf(stderr, "Failed to bind memory, vr %d.\n", vr);
>        vkFreeMemory(device, memory, NULL);
>        return VK_NULL_HANDLE;
>    }
>    return memory;
>}
>
>static VkBufferView create_buffer_view(VkDevice device, VkBuffer buffer, VkFormat format)
>{
>    VkBufferViewCreateInfo create_info;
>    VkBufferView buffer_view;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.buffer = buffer;
>    create_info.format = format;
>    create_info.offset = 0;
>    create_info.range = VK_WHOLE_SIZE;
>
>    if ((vr = vkCreateBufferView(device, &create_info, NULL, &buffer_view)) < 0)
>    {
>        fprintf(stderr, "Failed to create buffer view, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return buffer_view;
>}
>
>static VkImage create_image(VkDevice device, VkFormat format,
>        unsigned int width, unsigned int height, VkImageUsageFlags usage)
>{
>    VkImageCreateInfo image_info;
>    VkImage image;
>    VkResult vr;
>
>    image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
>    image_info.pNext = NULL;
>    image_info.flags = 0;
>    image_info.imageType = VK_IMAGE_TYPE_2D;
>    image_info.format = format;
>    image_info.extent.width = width;
>    image_info.extent.height = height;
>    image_info.extent.depth = 1;
>    image_info.arrayLayers = 1;
>    image_info.mipLevels = 1;
>    image_info.samples = VK_SAMPLE_COUNT_1_BIT;
>    image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
>    image_info.usage = usage;
>    image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
>    image_info.queueFamilyIndexCount = 0;
>    image_info.pQueueFamilyIndices = NULL;
>    image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
>
>    if ((vr = vkCreateImage(device, &image_info, NULL, &image)) < 0)
>    {
>        fprintf(stderr, "Failed to create Vulkan image, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return image;
>}
>
>static VkDeviceMemory allocate_image_memory(VkDevice device, VkPhysicalDevice physical_device,
>        VkImage image, VkMemoryPropertyFlags memory_flags)
>{
>    VkMemoryRequirements memory_requirements;
>    VkDeviceMemory memory;
>    VkResult vr;
>
>    vkGetImageMemoryRequirements(device, image, &memory_requirements);
>    memory = allocate_device_memory(device, physical_device, &memory_requirements, memory_flags);
>    assert(memory != VK_NULL_HANDLE);
>
>    if ((vr = vkBindImageMemory(device, image, memory, 0)) < 0)
>    {
>        fprintf(stderr, "Failed to bind memory, vr %d.\n", vr);
>        vkFreeMemory(device, memory, NULL);
>        return VK_NULL_HANDLE;
>    }
>    return memory;
>}
>
>static VkImageView create_image_view(VkDevice device, VkImage image, VkFormat format, VkImageAspectFlags aspect)
>{
>    VkImageViewCreateInfo create_info;
>    VkImageView image_view;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.image = image;
>    create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
>    create_info.format = format;
>    create_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
>    create_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
>    create_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
>    create_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
>    create_info.subresourceRange.aspectMask = aspect;
>    create_info.subresourceRange.baseMipLevel = 0;
>    create_info.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
>    create_info.subresourceRange.baseArrayLayer = 0;
>    create_info.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
>
>    if ((vr = vkCreateImageView(device, &create_info, NULL, &image_view)) < 0)
>    {
>        fprintf(stderr, "Failed to create image view, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return image_view;
>}
>
>static VkSampler create_sampler(VkDevice device)
>{
>    VkSamplerCreateInfo create_info;
>    VkSampler sampler;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.magFilter = VK_FILTER_NEAREST;
>    create_info.minFilter = VK_FILTER_NEAREST;
>    create_info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
>    create_info.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
>    create_info.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
>    create_info.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
>    create_info.mipLodBias = 0;
>    create_info.maxAnisotropy = 1;
>    create_info.compareEnable = VK_TRUE;
>    create_info.compareOp = VK_COMPARE_OP_LESS;
>    create_info.minLod = 0;
>    create_info.maxLod = 1000;
>    create_info.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
>    create_info.unnormalizedCoordinates = VK_FALSE;
>
>    if ((vr = vkCreateSampler(device, &create_info, NULL, &sampler)) < 0)
>    {
>        fprintf(stderr, "Failed to create sampler, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return sampler;
>}
>
>static VkFramebuffer create_framebuffer(VkDevice device,
>        VkRenderPass render_pass, VkImageView image_view, unsigned int width, unsigned int height)
>{
>    VkFramebufferCreateInfo create_info;
>    VkFramebuffer framebuffer;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.renderPass = render_pass;
>    create_info.attachmentCount = 1;
>    create_info.pAttachments = &image_view;
>    create_info.width = width;
>    create_info.height = height;
>    create_info.layers = 1;
>
>    if ((vr = vkCreateFramebuffer(device, &create_info, NULL, &framebuffer)) < 0)
>    {
>        fprintf(stderr, "Failed to create framebuffer, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return framebuffer;
>}
>
>static void cmd_buffer_barrier(VkCommandBuffer command_buffer, VkBuffer buffer,
>        VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask,
>        VkAccessFlags src_access_mask, VkAccessFlags dst_access_mask)
>{
>    VkBufferMemoryBarrier buffer_barrier;
>
>    buffer_barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
>    buffer_barrier.pNext = NULL;
>    buffer_barrier.srcAccessMask = src_access_mask;
>    buffer_barrier.dstAccessMask = dst_access_mask;
>    buffer_barrier.srcQueueFamilyIndex = 0;
>    buffer_barrier.dstQueueFamilyIndex = 0;
>    buffer_barrier.buffer = buffer;
>    buffer_barrier.offset = 0;
>    buffer_barrier.size = VK_WHOLE_SIZE;
>
>    vkCmdPipelineBarrier(command_buffer, src_stage_mask, dst_stage_mask, 0,
>            0, NULL, 1, &buffer_barrier, 0, NULL);
>}
>
>static void cmd_image_barrier(VkCommandBuffer command_buffer, VkImage image,
>        VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask,
>        VkAccessFlags src_access_mask, VkAccessFlags dst_access_mask,
>        VkImageLayout old_layout, VkImageLayout new_layout, VkImageAspectFlags aspect)
>{
>    VkImageMemoryBarrier image_barrier;
>
>    image_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
>    image_barrier.pNext = NULL;
>    image_barrier.srcAccessMask = src_access_mask;
>    image_barrier.dstAccessMask = dst_access_mask;
>    image_barrier.oldLayout = old_layout;
>    image_barrier.newLayout = new_layout;
>    image_barrier.srcQueueFamilyIndex = 0;
>    image_barrier.dstQueueFamilyIndex = 0;
>    image_barrier.image = image;
>    image_barrier.subresourceRange.aspectMask = aspect;
>    image_barrier.subresourceRange.baseMipLevel = 0;
>    image_barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
>    image_barrier.subresourceRange.baseArrayLayer = 0;
>    image_barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
>
>    vkCmdPipelineBarrier(command_buffer, src_stage_mask, dst_stage_mask, 0,
>            0, NULL, 0, NULL, 1, &image_barrier);
>}
>
>static void cmd_copy_buffer(VkCommandBuffer command_buffer,
>        VkBuffer src_buffer, VkBuffer dst_buffer,
>        VkDeviceSize src_offset, VkDeviceSize dst_offset, VkDeviceSize size)
>{
>    VkBufferCopy region;
>
>    region.srcOffset = src_offset;
>    region.dstOffset = dst_offset;
>    region.size = size;
>
>    vkCmdCopyBuffer(command_buffer, src_buffer, dst_buffer, 1, &region);
>}
>
>static void cmd_copy_image_to_buffer(VkCommandBuffer command_buffer,
>        VkImage src_image, VkImageLayout image_layout, VkBuffer dst_buffer,
>        unsigned int width, unsigned int height)
>{
>    VkBufferImageCopy region;
>
>    region.bufferOffset = 0;
>    region.bufferRowLength = 0;
>    region.bufferImageHeight = 0;
>    region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
>    region.imageSubresource.mipLevel = 0;
>    region.imageSubresource.baseArrayLayer = 0;
>    region.imageSubresource.layerCount = 1;
>    region.imageOffset.x = 0;
>    region.imageOffset.y = 0;
>    region.imageOffset.z = 0;
>    region.imageExtent.width = width;
>    region.imageExtent.height = height;
>    region.imageExtent.depth = 1;
>    vkCmdCopyImageToBuffer(command_buffer, src_image, image_layout, dst_buffer, 1, &region);
>}
>
>static void cmd_clear_color_attachment(VkCommandBuffer command_buffer,
>        unsigned int index, unsigned int width, unsigned int height,
>        float r, float g, float b, float a)
>{
>    VkClearAttachment attachment;
>    VkClearRect rect;
>
>    attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
>    attachment.colorAttachment = index;
>    attachment.clearValue.color.float32[0] = r;
>    attachment.clearValue.color.float32[1] = g;
>    attachment.clearValue.color.float32[2] = b;
>    attachment.clearValue.color.float32[3] = a;
>
>    rect.rect.offset.x = 0;
>    rect.rect.offset.y = 0;
>    rect.rect.extent.width = width;
>    rect.rect.extent.height = height;
>    rect.baseArrayLayer = 0;
>    rect.layerCount = 1;
>
>    vkCmdClearAttachments(command_buffer, 1, &attachment, 1, &rect);
>}
>
>static void cmd_clear_depth_image(VkCommandBuffer command_buffer,
>        VkImage image, float depth)
>{
>    VkClearDepthStencilValue clear_value;
>    VkImageSubresourceRange range;
>
>    clear_value.depth = depth;
>    clear_value.stencil = 0;
>
>    range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
>    range.baseMipLevel = 0;
>    range.levelCount = VK_REMAINING_MIP_LEVELS;
>    range.baseArrayLayer = 0;
>    range.layerCount = VK_REMAINING_ARRAY_LAYERS;
>
>    vkCmdClearDepthStencilImage(command_buffer, image,
>            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_value, 1, &range);
>}
>
>static void cmd_begin_render_pass(VkCommandBuffer command_buffer,
>        VkRenderPass render_pass, VkFramebuffer framebuffer, unsigned int width, unsigned int height)
>{
>    struct VkRenderPassBeginInfo begin_desc;
>
>    begin_desc.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
>    begin_desc.pNext = NULL;
>    begin_desc.renderPass = render_pass;
>    begin_desc.framebuffer = framebuffer;
>    begin_desc.renderArea.offset.x = 0;
>    begin_desc.renderArea.offset.y = 0;
>    begin_desc.renderArea.extent.width = width;
>    begin_desc.renderArea.extent.height = height;
>    begin_desc.clearValueCount = 0;
>    begin_desc.pClearValues = NULL;
>    vkCmdBeginRenderPass(command_buffer, &begin_desc, VK_SUBPASS_CONTENTS_INLINE);
>}
>
>static void *map_memory(VkDevice device, VkDeviceMemory memory,
>        VkDeviceSize offset, VkDeviceSize size)
>{
>    VkResult vr;
>    void *ptr;
>
>    if ((vr = vkMapMemory(device, memory, offset, size, 0, &ptr)) < 0)
>    {
>        fprintf(stderr, "Failed to map memory, vr %d.\n", vr);
>        return NULL;
>    }
>    return ptr;
>}
>
>static uint32_t vs_code[] =
>{
>#if 0
>    ; SPIR-V
>    ; Version: 1.2
>    ; Generator: Khronos SPIR-V Tools Assembler; 0
>    ; Bound: 52
>    ; Schema: 0
>    OpCapability Shader
>    %1 = OpExtInstImport "GLSL.std.450"
>    OpMemoryModel Logical GLSL450
>    OpEntryPoint Vertex %2 "main" %gl_VertexIndex %gl_Position
>    OpDecorate %gl_VertexIndex BuiltIn VertexIndex
>    OpDecorate %gl_Position BuiltIn Position
>    %void = OpTypeVoid
>    %6 = OpTypeFunction %void
>    %int = OpTypeInt 32 1
>    %uint = OpTypeInt 32 0
>    %_ptr_Input_uint = OpTypePointer Input %uint
>    %gl_VertexIndex = OpVariable %_ptr_Input_uint Input
>    %float = OpTypeFloat 32
>    %v4float = OpTypeVector %float 4
>    %_ptr_Private_v4float = OpTypePointer Private %v4float
>    %_ptr_Private_float = OpTypePointer Private %float
>    %uint_0 = OpConstant %uint 0
>    %_ptr_Output_v4float = OpTypePointer Output %v4float
>    %gl_Position = OpVariable %_ptr_Output_v4float Output
>    %_ptr_Function_v4float = OpTypePointer Function %v4float
>    %uint_31 = OpConstant %uint 31
>    %int_1 = OpConstant %int 1
>    %_ptr_Function_float = OpTypePointer Function %float
>    %uint_2 = OpConstant %uint 2
>    %v2float = OpTypeVector %float 2
>    %v2uint = OpTypeVector %uint 2
>    %float_2 = OpConstant %float 2
>    %float_n2 = OpConstant %float -2
>    %25 = OpConstantComposite %v2float %float_2 %float_n2
>    %float_n1 = OpConstant %float -1
>    %float_1 = OpConstant %float 1
>    %28 = OpConstantComposite %v2float %float_n1 %float_1
>    %float_0 = OpConstant %float 0
>    %30 = OpConstantComposite %v2float %float_0 %float_1
>    %31 = OpUndef %v4float
>    %2 = OpFunction %void None %6
>    %32 = OpLabel
>    %33 = OpLoad %uint %gl_VertexIndex
>    %34 = OpBitwiseAnd %int %int_1 %uint_31
>    %35 = OpBitwiseAnd %int %int_1 %uint_31
>    %36 = OpBitFieldInsert %uint %uint_0 %33 %34 %35
>    %37 = OpBitcast %float %36
>    %38 = OpCompositeInsert %v4float %37 %31 0
>    %39 = OpBitwiseAnd %uint %33 %uint_2
>    %40 = OpBitcast %float %39
>    %41 = OpCompositeInsert %v4float %40 %38 2
>    %42 = OpVectorShuffle %v2float %41 %41 0 2
>    %43 = OpBitcast %v2uint %42
>    %44 = OpConvertUToF %v2float %43
>    %45 = OpVectorShuffle %v4float %41 %44 4 5 2 3
>    %46 = OpVectorShuffle %v2float %45 %45 0 1
>    %47 = OpExtInst %v2float %1 Fma %46 %25 %28
>    %48 = OpLoad %v4float %gl_Position
>    %49 = OpVectorShuffle %v4float %48 %47 4 5 2 3
>    OpStore %gl_Position %49
>    %50 = OpLoad %v4float %gl_Position
>    %51 = OpVectorShuffle %v4float %50 %30 0 1 4 5
>    OpStore %gl_Position %51
>    OpReturn
>    OpFunctionEnd
>#endif
>    0x07230203, 0x00010200, 0x00070000, 0x00000034, 0x00000000, 0x00020011, 0x00000001, 0x0006000b,
>    0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, 0x00000000, 0x00000001,
>    0x0007000f, 0x00000000, 0x00000002, 0x6e69616d, 0x00000000, 0x00000003, 0x00000004, 0x00040047,
>    0x00000003, 0x0000000b, 0x0000002a, 0x00040047, 0x00000004, 0x0000000b, 0x00000000, 0x00020013,
>    0x00000005, 0x00030021, 0x00000006, 0x00000005, 0x00040015, 0x00000007, 0x00000020, 0x00000001,
>    0x00040015, 0x00000008, 0x00000020, 0x00000000, 0x00040020, 0x00000009, 0x00000001, 0x00000008,
>    0x0004003b, 0x00000009, 0x00000003, 0x00000001, 0x00030016, 0x0000000a, 0x00000020, 0x00040017,
>    0x0000000b, 0x0000000a, 0x00000004, 0x00040020, 0x0000000c, 0x00000006, 0x0000000b, 0x00040020,
>    0x0000000d, 0x00000006, 0x0000000a, 0x0004002b, 0x00000008, 0x0000000e, 0x00000000, 0x00040020,
>    0x0000000f, 0x00000003, 0x0000000b, 0x0004003b, 0x0000000f, 0x00000004, 0x00000003, 0x00040020,
>    0x00000010, 0x00000007, 0x0000000b, 0x0004002b, 0x00000008, 0x00000011, 0x0000001f, 0x0004002b,
>    0x00000007, 0x00000012, 0x00000001, 0x00040020, 0x00000013, 0x00000007, 0x0000000a, 0x0004002b,
>    0x00000008, 0x00000014, 0x00000002, 0x00040017, 0x00000015, 0x0000000a, 0x00000002, 0x00040017,
>    0x00000016, 0x00000008, 0x00000002, 0x0004002b, 0x0000000a, 0x00000017, 0x40000000, 0x0004002b,
>    0x0000000a, 0x00000018, 0xc0000000, 0x0005002c, 0x00000015, 0x00000019, 0x00000017, 0x00000018,
>    0x0004002b, 0x0000000a, 0x0000001a, 0xbf800000, 0x0004002b, 0x0000000a, 0x0000001b, 0x3f800000,
>    0x0005002c, 0x00000015, 0x0000001c, 0x0000001a, 0x0000001b, 0x0004002b, 0x0000000a, 0x0000001d,
>    0x00000000, 0x0005002c, 0x00000015, 0x0000001e, 0x0000001d, 0x0000001b, 0x00030001, 0x0000000b,
>    0x0000001f, 0x00050036, 0x00000005, 0x00000002, 0x00000000, 0x00000006, 0x000200f8, 0x00000020,
>    0x0004003d, 0x00000008, 0x00000021, 0x00000003, 0x000500c7, 0x00000007, 0x00000022, 0x00000012,
>    0x00000011, 0x000500c7, 0x00000007, 0x00000023, 0x00000012, 0x00000011, 0x000700c9, 0x00000008,
>    0x00000024, 0x0000000e, 0x00000021, 0x00000022, 0x00000023, 0x0004007c, 0x0000000a, 0x00000025,
>    0x00000024, 0x00060052, 0x0000000b, 0x00000026, 0x00000025, 0x0000001f, 0x00000000, 0x000500c7,
>    0x00000008, 0x00000027, 0x00000021, 0x00000014, 0x0004007c, 0x0000000a, 0x00000028, 0x00000027,
>    0x00060052, 0x0000000b, 0x00000029, 0x00000028, 0x00000026, 0x00000002, 0x0007004f, 0x00000015,
>    0x0000002a, 0x00000029, 0x00000029, 0x00000000, 0x00000002, 0x0004007c, 0x00000016, 0x0000002b,
>    0x0000002a, 0x00040070, 0x00000015, 0x0000002c, 0x0000002b, 0x0009004f, 0x0000000b, 0x0000002d,
>    0x00000029, 0x0000002c, 0x00000004, 0x00000005, 0x00000002, 0x00000003, 0x0007004f, 0x00000015,
>    0x0000002e, 0x0000002d, 0x0000002d, 0x00000000, 0x00000001, 0x0008000c, 0x00000015, 0x0000002f,
>    0x00000001, 0x00000032, 0x0000002e, 0x00000019, 0x0000001c, 0x0004003d, 0x0000000b, 0x00000030,
>    0x00000004, 0x0009004f, 0x0000000b, 0x00000031, 0x00000030, 0x0000002f, 0x00000004, 0x00000005,
>    0x00000002, 0x00000003, 0x0003003e, 0x00000004, 0x00000031, 0x0004003d, 0x0000000b, 0x00000032,
>    0x00000004, 0x0009004f, 0x0000000b, 0x00000033, 0x00000032, 0x0000001e, 0x00000000, 0x00000001,
>    0x00000004, 0x00000005, 0x0003003e, 0x00000004, 0x00000033, 0x000100fd, 0x00010038,
>};
>
>static uint32_t fs_code[] =
>{
>#if 0
>    ; SPIR-V
>    ; Version: 1.0
>    ; Generator: Khronos; 0
>    ; Bound: 59
>    ; Schema: 0
>               OpCapability Shader
>               OpMemoryModel Logical GLSL450
>               OpEntryPoint Fragment %main "main" %gl_FragCoord %o0
>               OpName %main "main"
>               OpName %cb1_struct "cb1_struct"
>               OpName %cb0_1 "cb0_1"
>               OpName %s1 "s1"
>               OpName %t0 "t0"
>               OpName %v0 "v0"
>               OpName %o0 "o0"
>               OpName %r0 "r0"
>               OpDecorate %_arr_v4float_uint_1 ArrayStride 16
>               OpDecorate %cb1_struct Block
>               OpMemberDecorate %cb1_struct 0 Offset 0
>               OpDecorate %cb0_1 DescriptorSet 0
>               OpDecorate %cb0_1 Binding 0
>               OpDecorate %s1 DescriptorSet 0
>               OpDecorate %s1 Binding 1
>               OpDecorate %t0 DescriptorSet 0
>               OpDecorate %t0 Binding 2
>               OpDecorate %gl_FragCoord BuiltIn FragCoord
>               OpDecorate %o0 Location 0
>       %void = OpTypeVoid
>          %2 = OpTypeFunction %void
>      %float = OpTypeFloat 32
>    %v4float = OpTypeVector %float 4
>       %uint = OpTypeInt 32 0
>     %uint_1 = OpConstant %uint 1
>%_arr_v4float_uint_1 = OpTypeArray %v4float %uint_1
> %cb1_struct = OpTypeStruct %_arr_v4float_uint_1
>%_ptr_Uniform_cb1_struct = OpTypePointer Uniform %cb1_struct
>      %cb0_1 = OpVariable %_ptr_Uniform_cb1_struct Uniform
>         %13 = OpTypeSampler
>%_ptr_UniformConstant_13 = OpTypePointer UniformConstant %13
>         %s1 = OpVariable %_ptr_UniformConstant_13 UniformConstant
>         %16 = OpTypeImage %float 2D 0 0 0 1 Unknown
>%_ptr_UniformConstant_16 = OpTypePointer UniformConstant %16
>         %t0 = OpVariable %_ptr_UniformConstant_16 UniformConstant
>%_ptr_Input_v4float = OpTypePointer Input %v4float
>%gl_FragCoord = OpVariable %_ptr_Input_v4float Input
>    %v2float = OpTypeVector %float 2
>%_ptr_Private_v4float = OpTypePointer Private %v4float
>         %v0 = OpVariable %_ptr_Private_v4float Private
>%_ptr_Output_v4float = OpTypePointer Output %v4float
>         %o0 = OpVariable %_ptr_Output_v4float Output
>%_ptr_Function_v4float = OpTypePointer Function %v4float
>%float_0_0015625 = OpConstant %float 0.0015625
>%float_0_00208333 = OpConstant %float 0.00208333
>         %36 = OpConstantComposite %v2float %float_0_0015625 %float_0_00208333
>         %41 = OpTypeImage %float 2D 1 0 0 1 Unknown
>         %43 = OpTypeSampledImage %41
>     %uint_0 = OpConstant %uint 0
>%_ptr_Uniform_v4float = OpTypePointer Uniform %v4float
>%_ptr_Uniform_float = OpTypePointer Uniform %float
>%_ptr_Function_float = OpTypePointer Function %float
>       %main = OpFunction %void None %2
>          %4 = OpLabel
>         %r0 = OpVariable %_ptr_Function_v4float Function
>         %21 = OpLoad %v4float %gl_FragCoord
>         %23 = OpVectorShuffle %v2float %21 %21 0 1
>         %26 = OpLoad %v4float %v0
>         %27 = OpVectorShuffle %v4float %26 %23 4 5 2 3
>               OpStore %v0 %27
>         %32 = OpLoad %v4float %v0
>         %33 = OpVectorShuffle %v2float %32 %32 0 1
>         %37 = OpFMul %v2float %33 %36
>         %38 = OpLoad %v4float %r0
>         %39 = OpVectorShuffle %v4float %38 %37 4 5 2 3
>               OpStore %r0 %39
>         %40 = OpLoad %16 %t0
>         %42 = OpLoad %13 %s1
>         %44 = OpSampledImage %43 %40 %42
>         %45 = OpLoad %v4float %r0
>         %46 = OpVectorShuffle %v4float %45 %45 0 1 0 0
>         %49 = OpAccessChain %_ptr_Uniform_v4float %cb0_1 %uint_0 %uint_0
>         %51 = OpInBoundsAccessChain %_ptr_Uniform_float %49 %uint_0
>         %52 = OpLoad %float %51
>         %53 = OpImageSampleDrefImplicitLod %v4float %44 %46 %52
>         %54 = OpCompositeExtract %float %53 0
>         %56 = OpInBoundsAccessChain %_ptr_Function_float %r0 %uint_0
>               OpStore %56 %54
>         %57 = OpLoad %v4float %r0
>         %58 = OpVectorShuffle %v4float %57 %57 0 0 0 0
>               OpStore %o0 %58
>               OpReturn
>               OpFunctionEnd
>#endif
>    0x07230203, 0x00010000, 0x00000000, 0x0000003b, 0x00000000, 0x00020011, 0x00000001, 0x0003000e,
>    0x00000000, 0x00000001, 0x0007000f, 0x00000004, 0x00000003, 0x6e69616d, 0x00000000, 0x00000014,
>    0x0000001d, 0x00040005, 0x00000003, 0x6e69616d, 0x00000000, 0x00050005, 0x0000000a, 0x5f316263,
>    0x75727473, 0x00007463, 0x00040005, 0x0000000c, 0x5f306263, 0x00000031, 0x00030005, 0x0000000f,
>    0x00003173, 0x00030005, 0x00000012, 0x00003074, 0x00030005, 0x00000019, 0x00003076, 0x00030005,
>    0x0000001d, 0x0000306f, 0x00030005, 0x0000001f, 0x00003072, 0x00040047, 0x00000009, 0x00000006,
>    0x00000010, 0x00030047, 0x0000000a, 0x00000002, 0x00050048, 0x0000000a, 0x00000000, 0x00000023,
>    0x00000000, 0x00040047, 0x0000000c, 0x00000022, 0x00000000, 0x00040047, 0x0000000c, 0x00000021,
>    0x00000000, 0x00040047, 0x0000000f, 0x00000022, 0x00000000, 0x00040047, 0x0000000f, 0x00000021,
>    0x00000001, 0x00040047, 0x00000012, 0x00000022, 0x00000000, 0x00040047, 0x00000012, 0x00000021,
>    0x00000002, 0x00040047, 0x00000014, 0x0000000b, 0x0000000f, 0x00040047, 0x0000001d, 0x0000001e,
>    0x00000000, 0x00020013, 0x00000001, 0x00030021, 0x00000002, 0x00000001, 0x00030016, 0x00000005,
>    0x00000020, 0x00040017, 0x00000006, 0x00000005, 0x00000004, 0x00040015, 0x00000007, 0x00000020,
>    0x00000000, 0x0004002b, 0x00000007, 0x00000008, 0x00000001, 0x0004001c, 0x00000009, 0x00000006,
>    0x00000008, 0x0003001e, 0x0000000a, 0x00000009, 0x00040020, 0x0000000b, 0x00000002, 0x0000000a,
>    0x0004003b, 0x0000000b, 0x0000000c, 0x00000002, 0x0002001a, 0x0000000d, 0x00040020, 0x0000000e,
>    0x00000000, 0x0000000d, 0x0004003b, 0x0000000e, 0x0000000f, 0x00000000, 0x00090019, 0x00000010,
>    0x00000005, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000000, 0x00040020,
>    0x00000011, 0x00000000, 0x00000010, 0x0004003b, 0x00000011, 0x00000012, 0x00000000, 0x00040020,
>    0x00000013, 0x00000001, 0x00000006, 0x0004003b, 0x00000013, 0x00000014, 0x00000001, 0x00040017,
>    0x00000016, 0x00000005, 0x00000002, 0x00040020, 0x00000018, 0x00000006, 0x00000006, 0x0004003b,
>    0x00000018, 0x00000019, 0x00000006, 0x00040020, 0x0000001c, 0x00000003, 0x00000006, 0x0004003b,
>    0x0000001c, 0x0000001d, 0x00000003, 0x00040020, 0x0000001e, 0x00000007, 0x00000006, 0x0004002b,
>    0x00000005, 0x00000022, 0x3acccccd, 0x0004002b, 0x00000005, 0x00000023, 0x3b088889, 0x0005002c,
>    0x00000016, 0x00000024, 0x00000022, 0x00000023, 0x00090019, 0x00000029, 0x00000005, 0x00000001,
>    0x00000001, 0x00000000, 0x00000000, 0x00000001, 0x00000000, 0x0003001b, 0x0000002b, 0x00000029,
>    0x0004002b, 0x00000007, 0x0000002f, 0x00000000, 0x00040020, 0x00000030, 0x00000002, 0x00000006,
>    0x00040020, 0x00000032, 0x00000002, 0x00000005, 0x00040020, 0x00000037, 0x00000007, 0x00000005,
>    0x00050036, 0x00000001, 0x00000003, 0x00000000, 0x00000002, 0x000200f8, 0x00000004, 0x0004003b,
>    0x0000001e, 0x0000001f, 0x00000007, 0x0004003d, 0x00000006, 0x00000015, 0x00000014, 0x0007004f,
>    0x00000016, 0x00000017, 0x00000015, 0x00000015, 0x00000000, 0x00000001, 0x0004003d, 0x00000006,
>    0x0000001a, 0x00000019, 0x0009004f, 0x00000006, 0x0000001b, 0x0000001a, 0x00000017, 0x00000004,
>    0x00000005, 0x00000002, 0x00000003, 0x0003003e, 0x00000019, 0x0000001b, 0x0004003d, 0x00000006,
>    0x00000020, 0x00000019, 0x0007004f, 0x00000016, 0x00000021, 0x00000020, 0x00000020, 0x00000000,
>    0x00000001, 0x00050085, 0x00000016, 0x00000025, 0x00000021, 0x00000024, 0x0004003d, 0x00000006,
>    0x00000026, 0x0000001f, 0x0009004f, 0x00000006, 0x00000027, 0x00000026, 0x00000025, 0x00000004,
>    0x00000005, 0x00000002, 0x00000003, 0x0003003e, 0x0000001f, 0x00000027, 0x0004003d, 0x00000010,
>    0x00000028, 0x00000012, 0x0004003d, 0x0000000d, 0x0000002a, 0x0000000f, 0x00050056, 0x0000002b,
>    0x0000002c, 0x00000028, 0x0000002a, 0x0004003d, 0x00000006, 0x0000002d, 0x0000001f, 0x0009004f,
>    0x00000006, 0x0000002e, 0x0000002d, 0x0000002d, 0x00000000, 0x00000001, 0x00000000, 0x00000000,
>    0x00060041, 0x00000030, 0x00000031, 0x0000000c, 0x0000002f, 0x0000002f, 0x00050042, 0x00000032,
>    0x00000033, 0x00000031, 0x0000002f, 0x0004003d, 0x00000005, 0x00000034, 0x00000033, 0x00060059,
>    0x00000006, 0x00000035, 0x0000002c, 0x0000002e, 0x00000034, 0x00050051, 0x00000005, 0x00000036,
>    0x00000035, 0x00000000, 0x00050042, 0x00000037, 0x00000038, 0x0000001f, 0x0000002f, 0x0003003e,
>    0x00000038, 0x00000036, 0x0004003d, 0x00000006, 0x00000039, 0x0000001f, 0x0009004f, 0x00000006,
>    0x0000003a, 0x00000039, 0x00000039, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0003003e,
>    0x0000001d, 0x0000003a, 0x000100fd, 0x00010038,
>};
>
>static uint32_t check_uint32(uint32_t value, uint32_t expected_value)
>{
>    if (value != expected_value)
>        printf("Got value %u, expected %u.\n", value, expected_value);
>}
>
>int main(int argc, char **argv)
>{
>    VkDeviceMemory uniform_memory, readback_memory, image_memory;
>    VkWriteDescriptorSet write_descriptors[3];
>    VkBuffer uniform_buffer, readback_buffer;
>    VkDescriptorBufferInfo buffer_info;
>    VkDeviceMemory depth_image_memory;
>    VkPhysicalDevice physical_device;
>    VkDescriptorSetLayout set_layout;
>    VkDescriptorPool descriptor_pool;
>    VkCommandBuffer command_buffer;
>    VkImageView depth_image_view;
>    VkCommandPool command_pool;
>    VkFramebuffer framebuffer;
>    VkRenderPass render_pass;
>    VkPipelineLayout layout;
>    VkImageView image_view;
>    VkShaderModule vs, fs;
>    VkInstance instance;
>    VkPipeline pipeline;
>    VkDescriptorSet set;
>    VkImage depth_image;
>    VkSampler sampler;
>    unsigned int x, y;
>    bool pass = true;
>    VkDevice device;
>    float expected;
>    VkImage image;
>    VkQueue queue;
>    float *result;
>
>    instance = create_instance();
>    assert(instance != VK_NULL_HANDLE);
>    physical_device = select_physical_device(instance);
>    assert(physical_device != VK_NULL_HANDLE);
>    device = create_device(instance, physical_device);
>    assert(device != VK_NULL_HANDLE);
>
>    vs = create_shader_module(device, sizeof(vs_code), &vs_code);
>    assert(vs != VK_NULL_HANDLE);
>    fs = create_shader_module(device, sizeof(fs_code), &fs_code);
>    assert(vs != VK_NULL_HANDLE);
>
>    set_layout = create_descriptor_set_layout(device);
>    assert(set_layout != VK_NULL_HANDLE);
>
>    layout = create_pipeline_layout(device, set_layout);
>    assert(layout != VK_NULL_HANDLE);
>    render_pass = create_render_pass(device);
>    assert(render_pass != VK_NULL_HANDLE);
>
>    pipeline = create_graphics_pipeline(device, layout, vs, fs, render_pass);
>    assert(pipeline != VK_NULL_HANDLE);
>
>    descriptor_pool = create_descriptor_pool(device);
>    assert(descriptor_pool != VK_NULL_HANDLE);
>
>    set = allocate_descriptor_set(device, descriptor_pool, set_layout);
>    assert(set != VK_NULL_HANDLE);
>
>    vkGetDeviceQueue(device, 0, 0, &queue);
>
>    command_pool = create_command_pool(device, 0);
>    assert(command_pool != VK_NULL_HANDLE);
>
>    command_buffer = allocate_command_buffer(device, command_pool);
>    assert(command_buffer != VK_NULL_HANDLE);
>
>    /* create resources */
>    uniform_buffer = create_buffer(device, sizeof(uint32_t), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
>            | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
>    assert(uniform_buffer != VK_NULL_HANDLE);
>    uniform_memory = allocate_buffer_memory(device, physical_device, uniform_buffer,
>            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
>    assert(uniform_memory != VK_NULL_HANDLE);
>
>    readback_buffer = create_buffer(device, 32 * 32 * 4 * 4, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
>    assert(readback_buffer != VK_NULL_HANDLE);
>    readback_memory = allocate_buffer_memory(device, physical_device, readback_buffer,
>            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
>    assert(readback_memory != VK_NULL_HANDLE);
>
>    image = create_image(device, VK_FORMAT_R32G32B32A32_SFLOAT, 32, 32,
>            VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
>    assert(image != VK_NULL_HANDLE);
>    image_memory = allocate_image_memory(device, physical_device, image,
>            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
>    image_view = create_image_view(device, image, VK_FORMAT_R32G32B32A32_SFLOAT, VK_IMAGE_ASPECT_COLOR_BIT);
>    assert(image_view != VK_NULL_HANDLE);
>
>    framebuffer = create_framebuffer(device, render_pass, image_view, 32, 32);
>    assert(framebuffer != VK_NULL_HANDLE);
>
>    sampler = create_sampler(device);
>    assert(sampler != VK_NULL_HANDLE);
>
>    /* VK_FORMAT_D32_SFLOAT works fine */
>    depth_image = create_image(device, VK_FORMAT_D24_UNORM_S8_UINT, 32, 32,
>            VK_IMAGE_USAGE_SAMPLED_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
>    assert(depth_image != VK_NULL_HANDLE);
>    depth_image_memory = allocate_image_memory(device, physical_device, depth_image,
>            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
>    depth_image_view = create_image_view(device, depth_image, VK_FORMAT_D24_UNORM_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT);
>    assert(depth_image_view != VK_NULL_HANDLE);
>
>    memset(&write_descriptors, 0, sizeof(write_descriptors));
>    write_descriptors[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
>    write_descriptors[0].pNext = NULL;
>    write_descriptors[0].dstSet = set;
>    write_descriptors[0].dstBinding = 0;
>    write_descriptors[0].descriptorCount = 1;
>    write_descriptors[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
>    write_descriptors[0].pBufferInfo = &buffer_info;
>    buffer_info.buffer = uniform_buffer;
>    buffer_info.offset = 0;
>    buffer_info.range = VK_WHOLE_SIZE;
>    write_descriptors[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
>    write_descriptors[1].pNext = NULL;
>    write_descriptors[1].dstSet = set;
>    write_descriptors[1].dstBinding = 1;
>    write_descriptors[1].descriptorCount = 1;
>    write_descriptors[1].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
>    VkDescriptorImageInfo image_info = { .sampler = sampler };
>    write_descriptors[1].pImageInfo = &image_info;
>    write_descriptors[2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
>    write_descriptors[2].pNext = NULL;
>    write_descriptors[2].dstSet = set;
>    write_descriptors[2].dstBinding = 2;
>    write_descriptors[2].descriptorCount = 1;
>    write_descriptors[2].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
>    VkDescriptorImageInfo image_info2 =
>    {
>        .imageView = depth_image_view,
>        .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
>    };
>    write_descriptors[2].pImageInfo = &image_info2;
>    vkUpdateDescriptorSets(device, ARRAY_SIZE(write_descriptors), write_descriptors, 0, NULL);
>
>    /* record commands */
>    begin_command_buffer(command_buffer);
>
>    if (argc > 1)
>    {
>        expected = 0.0f;
>        vkCmdFillBuffer(command_buffer, uniform_buffer, 0, VK_WHOLE_SIZE, 0x3f800000);
>    }
>    else
>    {
>        expected = 1.0f;
>        vkCmdFillBuffer(command_buffer, uniform_buffer, 0, VK_WHOLE_SIZE, 0x00000000);
>    }
>    cmd_buffer_barrier(command_buffer, uniform_buffer,
>            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
>            VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT);
>
>    cmd_image_barrier(command_buffer, depth_image,
>            VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
>            0, VK_ACCESS_TRANSFER_WRITE_BIT,
>            VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
>            VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
>    cmd_clear_depth_image(command_buffer, depth_image, 0.5f);
>    cmd_image_barrier(command_buffer, depth_image,
>            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
>            VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
>            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
>            VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
>
>    cmd_image_barrier(command_buffer, image,
>            VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
>            0, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
>            VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
>            VK_IMAGE_ASPECT_COLOR_BIT);
>
>    vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
>    vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
>            layout, 0, 1, &set, 0, NULL);
>
>    cmd_begin_render_pass(command_buffer, render_pass, framebuffer, 32, 32);
>    cmd_clear_color_attachment(command_buffer, 0, 32, 32, 2.0f, 2.0f, 2.0f, 2.0f);
>    vkCmdDraw(command_buffer, 3, 1, 0, 0);
>    vkCmdEndRenderPass(command_buffer);
>
>    cmd_image_barrier(command_buffer, image,
>            VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
>            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
>            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
>            VK_IMAGE_ASPECT_COLOR_BIT);
>    cmd_copy_image_to_buffer(command_buffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
>            readback_buffer, 32, 32);
>
>    end_command_buffer(command_buffer);
>
>    submit_commands(device, queue, command_buffer, true);
>
>    /* check results */
>    result = map_memory(device, readback_memory, 0, VK_WHOLE_SIZE);
>    assert(result != NULL);
>
>    printf("%f, %f, %f, %f\n", result[0], result[1], result[2], result[3]);
>
>    for (y = 0; y < 32; ++y)
>    {
>        for (x = 0; x < 32; ++x)
>        {
>            const float *p = &result[4 * (32 * y + x)];
>            if (p[0] != expected || p[1] != expected || p[2] != expected || p[3] != expected)
>            {
>                printf("Got %f, %f, %f, %f, expected %f, %f, %f, %f\n",
>                        p[0], p[1], p[2], p[3], expected, expected, expected, expected);
>                pass = false;
>                break;
>            }
>        }
>        if (!pass)
>            break;
>    }
>
>    vkDestroyFramebuffer(device, framebuffer, NULL);
>    vkDestroyImageView(device, image_view, NULL);
>    vkDestroyImageView(device, depth_image_view, NULL);
>    vkDestroyImage(device, image, NULL);
>    vkDestroyImage(device, depth_image, NULL);
>    vkDestroyBuffer(device, uniform_buffer, NULL);
>    vkDestroyBuffer(device, readback_buffer, NULL);
>    vkDestroySampler(device, sampler, NULL);
>    vkFreeMemory(device, uniform_memory, NULL);
>    vkFreeMemory(device, readback_memory, NULL);
>    vkFreeMemory(device, image_memory, NULL);
>    vkFreeMemory(device, depth_image_memory, NULL);
>
>    vkDestroyShaderModule(device, vs, NULL);
>    vkDestroyShaderModule(device, fs, NULL);
>    vkDestroyPipeline(device, pipeline, NULL);
>    vkDestroyRenderPass(device, render_pass, NULL);
>    vkDestroyPipelineLayout(device, layout, NULL);
>    vkDestroyDescriptorSetLayout(device, set_layout, NULL);
>    vkDestroyDescriptorPool(device, descriptor_pool, NULL);
>    vkDestroyCommandPool(device, command_pool, NULL);
>
>    vkDestroyDevice(device, NULL);
>    vkDestroyInstance(instance, NULL);
>    return 0;
>}

Actions: View

Attachments on bug 106528: 139576

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.