ash/examples/texture/src/main.rs

#![allow(dead_code)]
#[macro_use]
extern crate ash;
extern crate image;

extern crate glfw;

use ash::vk;
use std::default::Default;
use glfw::*;
use ash::entry::Entry;
use ash::instance::Instance;
use ash::device::Device;
use std::ptr;
use std::ffi::{CStr, CString};
use std::mem;
use std::path::Path;
use std::fs::File;
use std::io::Read;

// Simple offset_of macro akin to C++ offsetof
macro_rules! offset_of{
    ($base: path, $field: ident) => {
        unsafe{
            let b: $base = mem::uninitialized();
            (&b.$field as *const _ as isize) - (&b as *const _ as isize)
        }
    }
}

// Cross platform surface creation with GLFW
#[cfg(all(unix, not(target_os = "android")))]
fn create_surface(instance: &Instance, window: &Window) -> Result<vk::SurfaceKHR, vk::Result> {
    let x11_display = window.glfw.get_x11_display();
    let x11_window = window.get_x11_window();
    let x11_create_info = vk::XlibSurfaceCreateInfoKHR {
        s_type: vk::StructureType::XlibSurfaceCreateInfoKhr,
        p_next: ptr::null(),
        flags: Default::default(),
        window: x11_window as vk::Window,
        dpy: x11_display as *mut vk::Display,
    };
    instance.create_xlib_surface_khr(&x11_create_info)
}

#[cfg(all(unix, not(target_os = "android")))]
fn extension_names() -> Vec<CString> {
    vec![CString::new("VK_KHR_surface").unwrap(),
         CString::new("VK_KHR_xlib_surface").unwrap(),
         CString::new("VK_EXT_debug_report").unwrap()]
}

#[cfg(all(windows))]
fn extension_names() -> Vec<CString> {
    vec![CString::new("VK_KHR_surface").unwrap(),
         CString::new("VK_KHR_win32_surface").unwrap(),
         CString::new("VK_EXT_debug_report").unwrap()]
}

unsafe extern "system" fn vulkan_debug_callback(flags: vk::DebugReportFlagsEXT,
                                                obj_type: vk::DebugReportObjectTypeEXT,
                                                obj: u64,
                                                loc: usize,
                                                message: i32,
                                                p_layer_prefix: *const i8,
                                                p_message: *const i8,
                                                data: *mut ())
                                                -> u32 {
    println!("{:?}", CStr::from_ptr(p_message));
    1
}
fn handle_window_event(window: &mut glfw::Window, event: glfw::WindowEvent) {
    match event {
        glfw::WindowEvent::Key(Key::Escape, _, Action::Press, _) => window.set_should_close(true),
        _ => {}
    }
}

pub fn find_memorytype_index(memory_req: &vk::MemoryRequirements,
                             memory_prop: &vk::PhysicalDeviceMemoryProperties,
                             flags: vk::MemoryPropertyFlags)
                             -> Option<u32> {
    let mut memory_type_bits = memory_req.memory_type_bits;
    for (index, ref memory_type) in memory_prop.memory_types.iter().enumerate() {
        if (memory_type.property_flags & flags) == flags {
            return Some(index as u32);
        }
        memory_type_bits = memory_type_bits >> 1;
    }
    None
}

#[derive(Clone, Debug, Copy)]
struct Vertex {
    pos: [f32; 4],
    uv: [f32; 2],
}
fn main() {
    let mut glfw = glfw::init(glfw::FAIL_ON_ERRORS).unwrap();

    let window_width = 1920;
    let window_height = 1080;

    let (mut window, events) = glfw.create_window(window_width,
                       window_height,
                       "Hello this is window",
                       glfw::WindowMode::Windowed)
        .expect("Failed to create GLFW window.");

    window.set_key_polling(true);
    window.make_current();
    glfw.set_swap_interval(0);
    let entry = Entry::load_vulkan().unwrap();
    let instance_ext_props = entry.enumerate_instance_extension_properties().unwrap();
    let app_name = CString::new("VulkanTriangle").unwrap();
    let raw_name = app_name.as_ptr();

    let layer_names = [CString::new("VK_LAYER_LUNARG_standard_validation").unwrap()];
    let layers_names_raw: Vec<*const i8> = layer_names.iter()
        .map(|raw_name| raw_name.as_ptr())
        .collect();
    let extension_names = extension_names();
    let extension_names_raw: Vec<*const i8> = extension_names.iter()
        .map(|raw_name| raw_name.as_ptr())
        .collect();
    let appinfo = vk::ApplicationInfo {
        p_application_name: raw_name,
        s_type: vk::StructureType::ApplicationInfo,
        p_next: ptr::null(),
        application_version: 0,
        p_engine_name: raw_name,
        engine_version: 0,
        api_version: vk_make_version!(1, 0, 36),
    };
    let create_info = vk::InstanceCreateInfo {
        s_type: vk::StructureType::InstanceCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        p_application_info: &appinfo,
        pp_enabled_layer_names: layers_names_raw.as_ptr(),
        enabled_layer_count: layers_names_raw.len() as u32,
        pp_enabled_extension_names: extension_names_raw.as_ptr(),
        enabled_extension_count: extension_names_raw.len() as u32,
    };
    let instance: Instance = entry.create_instance(&create_info).expect("Instance creation error");
    let debug_info = vk::DebugReportCallbackCreateInfoEXT {
        s_type: vk::StructureType::DebugReportCallbackCreateInfoExt,
        p_next: ptr::null(),
        flags: vk::DEBUG_REPORT_ERROR_BIT_EXT | vk::DEBUG_REPORT_WARNING_BIT_EXT |
               vk::DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
        pfn_callback: vulkan_debug_callback,
        p_user_data: ptr::null_mut(),
    };
    let debug_call_back = instance.create_debug_report_callback_ext(&debug_info).unwrap();
    let surface = create_surface(&instance, &window).unwrap();
    let pdevices = instance.enumerate_physical_devices().expect("Physical device error");
    let (pdevice, queue_family_index) = pdevices.iter()
        .map(|pdevice| {
            instance.get_physical_device_queue_family_properties(*pdevice)
                .iter()
                .enumerate()
                .filter_map(|(index, ref info)| {
                    let supports_graphic_and_surface =
                        info.queue_flags.subset(vk::QUEUE_GRAPHICS_BIT) &&
                        instance.get_physical_device_surface_support_khr(*pdevice,
                                                                         index as u32,
                                                                         surface);
                    match supports_graphic_and_surface {
                        true => Some((*pdevice, index)),
                        _ => None,
                    }
                })
                .nth(0)
        })
        .filter_map(|v| v)
        .nth(0)
        .expect("Couldn't find suitable device.");
    let queue_family_index = queue_family_index as u32;
    let device_extension_names = [CString::new("VK_KHR_swapchain").unwrap()];
    let device_extension_names_raw: Vec<*const i8> = device_extension_names.iter()
        .map(|raw_name| raw_name.as_ptr())
        .collect();
    let features = vk::PhysicalDeviceFeatures { shader_clip_distance: 1, ..Default::default() };
    let priorities = [1.0];
    let queue_info = vk::DeviceQueueCreateInfo {
        s_type: vk::StructureType::DeviceQueueCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        queue_family_index: queue_family_index as u32,
        p_queue_priorities: priorities.as_ptr(),
        queue_count: priorities.len() as u32,
    };
    let device_create_info = vk::DeviceCreateInfo {
        s_type: vk::StructureType::DeviceCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        queue_create_info_count: 1,
        p_queue_create_infos: &queue_info,
        enabled_layer_count: 0,
        pp_enabled_layer_names: ptr::null(),
        enabled_extension_count: device_extension_names_raw.len() as u32,
        pp_enabled_extension_names: device_extension_names_raw.as_ptr(),
        p_enabled_features: &features,
    };
    let device: Device = instance.create_device(pdevice, &device_create_info)
        .unwrap();
    let present_queue = device.get_device_queue(queue_family_index as u32, 0);

    let surface_formats = instance.get_physical_device_surface_formats_khr(pdevice, surface)
        .unwrap();
    let surface_format = surface_formats.iter()
        .map(|sfmt| {
            match sfmt.format {
                vk::Format::Undefined => {
                    vk::SurfaceFormatKHR {
                        format: vk::Format::B8g8r8Unorm,
                        color_space: sfmt.color_space,
                    }
                }
                _ => sfmt.clone(),
            }
        })
        .nth(0)
        .expect("Unable to find suitable surface format.");
    let surface_capabilities =
        instance.get_physical_device_surface_capabilities_khr(pdevice, surface).unwrap();
    let desired_image_count = surface_capabilities.min_image_count + 1;
    assert!(surface_capabilities.min_image_count <= desired_image_count &&
            surface_capabilities.max_image_count >= desired_image_count,
            "Image count err");
    let surface_resoultion = match surface_capabilities.current_extent.width {
        std::u32::MAX => {
            vk::Extent2D {
                width: window_width,
                height: window_height,
            }
        }
        _ => surface_capabilities.current_extent,
    };

    let pre_transform = if surface_capabilities.supported_transforms
        .subset(vk::SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
        vk::SURFACE_TRANSFORM_IDENTITY_BIT_KHR
    } else {
        surface_capabilities.current_transform
    };
    let present_modes = instance.get_physical_device_surface_present_modes_khr(pdevice, surface)
        .unwrap();
    let present_mode = present_modes.iter()
        .cloned()
        .find(|&mode| mode == vk::PresentModeKHR::Mailbox)
        .unwrap_or(vk::PresentModeKHR::Fifo);
    let swapchain_create_info = vk::SwapchainCreateInfoKHR {
        s_type: vk::StructureType::SwapchainCreateInfoKhr,
        p_next: ptr::null(),
        flags: Default::default(),
        surface: surface,
        min_image_count: desired_image_count,
        image_color_space: surface_format.color_space,
        image_format: surface_format.format,
        image_extent: surface_resoultion.clone(),
        image_usage: vk::IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
        image_sharing_mode: vk::SharingMode::Exclusive,
        pre_transform: pre_transform,
        composite_alpha: vk::COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
        present_mode: present_mode,
        clipped: 1,
        old_swapchain: vk::SwapchainKHR::null(),
        image_array_layers: 1,
        p_queue_family_indices: ptr::null(),
        queue_family_index_count: 0,
    };
    let swapchain = device.create_swapchain_khr(&swapchain_create_info).unwrap();
    let pool_create_info = vk::CommandPoolCreateInfo {
        s_type: vk::StructureType::CommandPoolCreateInfo,
        p_next: ptr::null(),
        flags: vk::COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
        queue_family_index: queue_family_index,
    };
    let pool = device.create_command_pool(&pool_create_info).unwrap();
    let command_buffer_allocate_info = vk::CommandBufferAllocateInfo {
        s_type: vk::StructureType::CommandBufferAllocateInfo,
        p_next: ptr::null(),
        command_buffer_count: 3,
        command_pool: pool,
        level: vk::CommandBufferLevel::Primary,
    };
    let command_buffers = device.allocate_command_buffers(&command_buffer_allocate_info).unwrap();
    let setup_command_buffer = command_buffers[0];
    let draw_command_buffer = command_buffers[1];
    let texture_command_buffer = command_buffers[2];

    let present_images = device.get_swapchain_images_khr(swapchain).unwrap();
    let present_image_views: Vec<vk::ImageView> = present_images.iter()
        .map(|&image| {
            let create_view_info = vk::ImageViewCreateInfo {
                s_type: vk::StructureType::ImageViewCreateInfo,
                p_next: ptr::null(),
                flags: Default::default(),
                view_type: vk::ImageViewType::Type2d,
                format: surface_format.format,
                components: vk::ComponentMapping {
                    r: vk::ComponentSwizzle::R,
                    g: vk::ComponentSwizzle::G,
                    b: vk::ComponentSwizzle::B,
                    a: vk::ComponentSwizzle::A,
                },
                subresource_range: vk::ImageSubresourceRange {
                    aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT,
                    base_mip_level: 0,
                    level_count: 1,
                    base_array_layer: 0,
                    layer_count: 1,
                },
                image: image,
            };
            device.create_image_view(&create_view_info).unwrap()
        })
        .collect();
    let device_memory_properties = instance.get_physical_device_memory_properties(pdevice);
    let depth_image_create_info = vk::ImageCreateInfo {
        s_type: vk::StructureType::ImageCreateInfo,
        p_next: ptr::null(),
        flags: vk::IMAGE_CREATE_SPARSE_BINDING_BIT,
        image_type: vk::ImageType::Type2d,
        format: vk::Format::D16Unorm,
        extent: vk::Extent3D {
            width: surface_resoultion.width,
            height: surface_resoultion.height,
            depth: 1,
        },
        mip_levels: 1,
        array_layers: 1,
        samples: vk::SAMPLE_COUNT_1_BIT,
        tiling: vk::ImageTiling::Optimal,
        usage: vk::IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
        sharing_mode: vk::SharingMode::Exclusive,
        queue_family_index_count: 0,
        p_queue_family_indices: ptr::null(),
        initial_layout: vk::ImageLayout::Undefined,
    };
    let depth_image = device.create_image(&depth_image_create_info).unwrap();
    let depth_image_memory_req = device.get_image_memory_requirements(depth_image);
    let depth_image_memory_index = find_memorytype_index(&depth_image_memory_req,
                                                         &device_memory_properties,
                                                         vk::MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
        .expect("Unable to find suitable memory index for depth image.");

    let depth_image_allocate_info = vk::MemoryAllocateInfo {
        s_type: vk::StructureType::MemoryAllocateInfo,
        p_next: ptr::null(),
        allocation_size: depth_image_memory_req.size,
        memory_type_index: depth_image_memory_index,
    };
    let depth_image_memory = device.allocate_memory(&depth_image_allocate_info).unwrap();
    device.bind_image_memory(depth_image, depth_image_memory, 0)
        .expect("Unable to bind depth image memory");

    let command_buffer_begin_info = vk::CommandBufferBeginInfo {
        s_type: vk::StructureType::CommandBufferBeginInfo,
        p_next: ptr::null(),
        p_inheritance_info: ptr::null(),
        flags: vk::COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
    };
    device.begin_command_buffer(setup_command_buffer, &command_buffer_begin_info).unwrap();
    let layout_transition_barrier = vk::ImageMemoryBarrier {
        s_type: vk::StructureType::ImageMemoryBarrier,
        p_next: ptr::null(),
        src_access_mask: Default::default(),
        dst_access_mask: vk::ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
                         vk::ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
        old_layout: vk::ImageLayout::Undefined,
        new_layout: vk::ImageLayout::DepthStencilAttachmentOptimal,
        src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED,
        dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED,
        image: depth_image,
        subresource_range: vk::ImageSubresourceRange {
            aspect_mask: vk::IMAGE_ASPECT_DEPTH_BIT,
            base_mip_level: 0,
            level_count: 1,
            base_array_layer: 0,
            layer_count: 1,
        },
    };
    device.cmd_pipeline_barrier(setup_command_buffer,
                                vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                vk::DependencyFlags::empty(),
                                &[],
                                &[],
                                &[layout_transition_barrier]);
    let wait_stage_mask = [vk::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT];
    let fence_create_info = vk::FenceCreateInfo {
        s_type: vk::StructureType::FenceCreateInfo,
        p_next: ptr::null(),
        flags: vk::FenceCreateFlags::empty(),
    };
    let submit_fence = device.create_fence(&fence_create_info).unwrap();
    let submit_info = vk::SubmitInfo {
        s_type: vk::StructureType::SubmitInfo,
        p_next: ptr::null(),
        wait_semaphore_count: 0,
        p_wait_semaphores: ptr::null(),
        signal_semaphore_count: 0,
        p_signal_semaphores: ptr::null(),
        p_wait_dst_stage_mask: wait_stage_mask.as_ptr(),
        command_buffer_count: 1,
        p_command_buffers: &setup_command_buffer,
    };
    device.end_command_buffer(setup_command_buffer).unwrap();
    device.queue_submit(present_queue, &[submit_info], submit_fence).unwrap();
    device.wait_for_fences(&[submit_fence], true, std::u64::MAX).unwrap();
    let depth_image_view_info = vk::ImageViewCreateInfo {
        s_type: vk::StructureType::ImageViewCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        view_type: vk::ImageViewType::Type2d,
        format: depth_image_create_info.format,
        components: vk::ComponentMapping {
            r: vk::ComponentSwizzle::Identity,
            g: vk::ComponentSwizzle::Identity,
            b: vk::ComponentSwizzle::Identity,
            a: vk::ComponentSwizzle::Identity,
        },
        subresource_range: vk::ImageSubresourceRange {
            aspect_mask: vk::IMAGE_ASPECT_DEPTH_BIT,
            base_mip_level: 0,
            level_count: 1,
            base_array_layer: 0,
            layer_count: 1,
        },
        image: depth_image,
    };
    let depth_image_view = device.create_image_view(&depth_image_view_info).unwrap();
    let renderpass_attachments = [vk::AttachmentDescription {
                                      format: surface_format.format,
                                      flags: vk::AttachmentDescriptionFlags::empty(),
                                      samples: vk::SAMPLE_COUNT_1_BIT,
                                      load_op: vk::AttachmentLoadOp::Clear,
                                      store_op: vk::AttachmentStoreOp::Store,
                                      stencil_load_op: vk::AttachmentLoadOp::DontCare,
                                      stencil_store_op: vk::AttachmentStoreOp::DontCare,
                                      initial_layout: vk::ImageLayout::Undefined,
                                      final_layout: vk::ImageLayout::PresentSrcKhr,
                                  },
                                  vk::AttachmentDescription {
                                      format: depth_image_create_info.format,
                                      flags: vk::AttachmentDescriptionFlags::empty(),
                                      samples: vk::SAMPLE_COUNT_1_BIT,
                                      load_op: vk::AttachmentLoadOp::Clear,
                                      store_op: vk::AttachmentStoreOp::DontCare,
                                      stencil_load_op: vk::AttachmentLoadOp::DontCare,
                                      stencil_store_op: vk::AttachmentStoreOp::DontCare,
                                      initial_layout:
                                          vk::ImageLayout::DepthStencilAttachmentOptimal,
                                      final_layout: vk::ImageLayout::DepthStencilAttachmentOptimal,
                                  }];
    let color_attachment_ref = vk::AttachmentReference {
        attachment: 0,
        layout: vk::ImageLayout::ColorAttachmentOptimal,
    };
    let depth_attachment_ref = vk::AttachmentReference {
        attachment: 1,
        layout: vk::ImageLayout::DepthStencilAttachmentOptimal,
    };
    let dependency = vk::SubpassDependency {
        dependency_flags: Default::default(),
        src_subpass: vk::VK_SUBPASS_EXTERNAL,
        dst_subpass: Default::default(),
        src_stage_mask: vk::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
        src_access_mask: Default::default(),
        dst_access_mask: vk::ACCESS_COLOR_ATTACHMENT_READ_BIT |
                         vk::ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
        dst_stage_mask: vk::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
    };
    let subpass = vk::SubpassDescription {
        color_attachment_count: 1,
        p_color_attachments: &color_attachment_ref,
        p_depth_stencil_attachment: &depth_attachment_ref,
        // TODO: Why is there no wrapper?
        flags: Default::default(),
        pipeline_bind_point: vk::PipelineBindPoint::Graphics,
        input_attachment_count: 0,
        p_input_attachments: ptr::null(),
        p_resolve_attachments: ptr::null(),
        preserve_attachment_count: 0,
        p_preserve_attachments: ptr::null(),
    };
    let renderpass_create_info = vk::RenderPassCreateInfo {
        s_type: vk::StructureType::RenderPassCreateInfo,
        flags: Default::default(),
        p_next: ptr::null(),
        attachment_count: renderpass_attachments.len() as u32,
        p_attachments: renderpass_attachments.as_ptr(),
        subpass_count: 1,
        p_subpasses: &subpass,
        dependency_count: 1,
        p_dependencies: &dependency,
    };
    let renderpass = device.create_render_pass(&renderpass_create_info).unwrap();
    let framebuffers: Vec<vk::Framebuffer> = present_image_views.iter()
        .map(|&present_image_view| {
            let framebuffer_attachments = [present_image_view, depth_image_view];
            let frame_buffer_create_info = vk::FramebufferCreateInfo {
                s_type: vk::StructureType::FramebufferCreateInfo,
                p_next: ptr::null(),
                flags: Default::default(),
                render_pass: renderpass,
                attachment_count: framebuffer_attachments.len() as u32,
                p_attachments: framebuffer_attachments.as_ptr(),
                width: surface_resoultion.width,
                height: surface_resoultion.height,
                layers: 1,
            };
            device.create_framebuffer(&frame_buffer_create_info).unwrap()
        })
        .collect();
    let index_buffer_data = [0u32, 1, 2, 2, 3, 0];
    let index_buffer_info = vk::BufferCreateInfo {
        s_type: vk::StructureType::BufferCreateInfo,
        p_next: ptr::null(),
        flags: vk::BufferCreateFlags::empty(),
        size: std::mem::size_of_val(&index_buffer_data) as u64,
        usage: vk::BUFFER_USAGE_INDEX_BUFFER_BIT,
        sharing_mode: vk::SharingMode::Exclusive,
        queue_family_index_count: 0,
        p_queue_family_indices: ptr::null(),
    };
    let index_buffer = device.create_buffer(&index_buffer_info).unwrap();
    let index_buffer_memory_req = device.get_buffer_memory_requirements(index_buffer);
    let index_buffer_memory_index = find_memorytype_index(&index_buffer_memory_req,
                                                          &device_memory_properties,
                                                          vk::MEMORY_PROPERTY_HOST_VISIBLE_BIT)
        .expect("Unable to find suitable memorytype for the index buffer.");
    let index_allocate_info = vk::MemoryAllocateInfo {
        s_type: vk::StructureType::MemoryAllocateInfo,
        p_next: ptr::null(),
        allocation_size: index_buffer_memory_req.size,
        memory_type_index: index_buffer_memory_index,
    };
    let index_buffer_memory = device.allocate_memory(&index_allocate_info).unwrap();
    let index_slice = device.map_memory::<u32>(index_buffer_memory,
                           0,
                           index_buffer_info.size,
                           vk::MemoryMapFlags::empty())
        .unwrap();
    index_slice.copy_from_slice(&index_buffer_data);
    device.unmap_memory(index_buffer_memory);
    device.bind_buffer_memory(index_buffer, index_buffer_memory, 0).unwrap();

    let uniform_color_buffer_info = vk::BufferCreateInfo {
        s_type: vk::StructureType::BufferCreateInfo,
        p_next: ptr::null(),
        flags: vk::BufferCreateFlags::empty(),
        size: 3 * std::mem::size_of::<f32>() as u64,
        usage: vk::BUFFER_USAGE_UNIFORM_BUFFER_BIT,
        sharing_mode: vk::SharingMode::Exclusive,
        queue_family_index_count: 0,
        p_queue_family_indices: ptr::null(),
    };
    let uniform_color_buffer_data = [0.0f32, 1.0, 1.0];
    let uniform_color_buffer = device.create_buffer(&uniform_color_buffer_info).unwrap();
    let uniform_color_buffer_memory_req =
        device.get_buffer_memory_requirements(uniform_color_buffer);
    let uniform_color_buffer_memory_index =
        find_memorytype_index(&uniform_color_buffer_memory_req,
                              &device_memory_properties,
                              vk::MEMORY_PROPERTY_HOST_VISIBLE_BIT)
            .expect("Unable to find suitable memorytype for the vertex buffer.");

    let uniform_color_buffer_allocate_info = vk::MemoryAllocateInfo {
        s_type: vk::StructureType::MemoryAllocateInfo,
        p_next: ptr::null(),
        allocation_size: uniform_color_buffer_memory_req.size,
        memory_type_index: uniform_color_buffer_memory_index,
    };
    let uniform_color_buffer_memory = device.allocate_memory(&uniform_color_buffer_allocate_info)
        .unwrap();
    let uniform_slice = device.map_memory::<f32>(uniform_color_buffer_memory,
                           0,
                           uniform_color_buffer_info.size,
                           vk::MemoryMapFlags::empty())
        .unwrap();
    uniform_slice.copy_from_slice(&uniform_color_buffer_data[..]);
    device.unmap_memory(uniform_color_buffer_memory);
    device.bind_buffer_memory(uniform_color_buffer, uniform_color_buffer_memory, 0).unwrap();
    let vertices = [Vertex {
                        pos: [-1.0, -1.0, 0.0, 1.0],
                        uv: [0.0, 1.0],
                    },
                    Vertex {
                        pos: [-1.0, 1.0, 0.0, 1.0],
                        uv: [0.0, 0.0],
                    },
                    Vertex {
                        pos: [1.0, 1.0, 0.0, 1.0],
                        uv: [1.0, 0.0],
                    },
                    Vertex {
                        pos: [1.0, -1.0, 0.0, 1.0],
                        uv: [1.0, 1.0],
                    }];
    let vertex_input_buffer_info = vk::BufferCreateInfo {
        s_type: vk::StructureType::BufferCreateInfo,
        p_next: ptr::null(),
        flags: vk::BufferCreateFlags::empty(),
        size: std::mem::size_of_val(&vertices) as u64,
        usage: vk::BUFFER_USAGE_VERTEX_BUFFER_BIT,
        sharing_mode: vk::SharingMode::Exclusive,
        queue_family_index_count: 0,
        p_queue_family_indices: ptr::null(),
    };
    let vertex_input_buffer = device.create_buffer(&vertex_input_buffer_info).unwrap();
    let vertex_input_buffer_memory_req = device.get_buffer_memory_requirements(vertex_input_buffer);
    let vertex_input_buffer_memory_index =
        find_memorytype_index(&vertex_input_buffer_memory_req,
                              &device_memory_properties,
                              vk::MEMORY_PROPERTY_HOST_VISIBLE_BIT)
            .expect("Unable to find suitable memorytype for the vertex buffer.");

    let vertex_buffer_allocate_info = vk::MemoryAllocateInfo {
        s_type: vk::StructureType::MemoryAllocateInfo,
        p_next: ptr::null(),
        allocation_size: vertex_input_buffer_memory_req.size,
        memory_type_index: vertex_input_buffer_memory_index,
    };
    let vertex_input_buffer_memory = device.allocate_memory(&vertex_buffer_allocate_info).unwrap();
    let slice = device.map_memory::<Vertex>(vertex_input_buffer_memory,
                              0,
                              vertex_input_buffer_info.size,
                              vk::MemoryMapFlags::empty())
        .unwrap();
    slice.copy_from_slice(&vertices);
    device.unmap_memory(vertex_input_buffer_memory);
    device.bind_buffer_memory(vertex_input_buffer, vertex_input_buffer_memory, 0).unwrap();


    let image = image::open("rust.png").unwrap().to_rgba();
    let image_dimensions = image.dimensions();
    let image_data = image.into_raw();
    let image_buffer_info = vk::BufferCreateInfo {
        s_type: vk::StructureType::BufferCreateInfo,
        p_next: ptr::null(),
        flags: vk::BufferCreateFlags::empty(),
        size: (std::mem::size_of::<u8>() * image_data.len()) as u64,
        usage: vk::BUFFER_USAGE_TRANSFER_SRC_BIT,
        sharing_mode: vk::SharingMode::Exclusive,
        queue_family_index_count: 0,
        p_queue_family_indices: ptr::null(),
    };
    let image_buffer = device.create_buffer(&image_buffer_info).unwrap();
    let image_buffer_memory_req = device.get_buffer_memory_requirements(image_buffer);
    let image_buffer_memory_index = find_memorytype_index(&image_buffer_memory_req,
                                                          &device_memory_properties,
                                                          vk::MEMORY_PROPERTY_HOST_VISIBLE_BIT)
        .expect("Unable to find suitable memorytype for the vertex buffer.");

    let vertex_buffer_allocate_info = vk::MemoryAllocateInfo {
        s_type: vk::StructureType::MemoryAllocateInfo,
        p_next: ptr::null(),
        allocation_size: image_buffer_memory_req.size,
        memory_type_index: image_buffer_memory_index,
    };
    let image_buffer_memory = device.allocate_memory(&vertex_buffer_allocate_info).unwrap();
    let image_buffer_slice = device.map_memory::<u8>(image_buffer_memory,
                          0,
                          image_buffer_info.size,
                          vk::MemoryMapFlags::empty())
        .unwrap();
    image_buffer_slice.copy_from_slice(&image_data);
    device.unmap_memory(image_buffer_memory);
    device.bind_buffer_memory(image_buffer, image_buffer_memory, 0).unwrap();

    let texture_create_info = vk::ImageCreateInfo {
        s_type: vk::StructureType::ImageCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        image_type: vk::ImageType::Type2d,
        format: vk::Format::R8g8b8a8Unorm,
        extent: vk::Extent3D {
            width: image_dimensions.0,
            height: image_dimensions.1,
            depth: 1,
        },
        mip_levels: 1,
        array_layers: 1,
        samples: vk::SAMPLE_COUNT_1_BIT,
        tiling: vk::ImageTiling::Optimal,
        usage: vk::IMAGE_USAGE_TRANSFER_DST_BIT | vk::IMAGE_USAGE_SAMPLED_BIT,
        sharing_mode: vk::SharingMode::Exclusive,
        queue_family_index_count: 0,
        p_queue_family_indices: ptr::null(),
        initial_layout: vk::ImageLayout::Undefined,
    };
    let texture_image = device.create_image(&texture_create_info).unwrap();
    let texture_memory_req = device.get_image_memory_requirements(texture_image);
    let texture_memory_index = find_memorytype_index(&texture_memory_req,
                                                     &device_memory_properties,
                                                     vk::MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
        .expect("Unable to find suitable memory index for depth image.");

    let texture_allocate_info = vk::MemoryAllocateInfo {
        s_type: vk::StructureType::MemoryAllocateInfo,
        p_next: ptr::null(),
        allocation_size: texture_memory_req.size,
        memory_type_index: texture_memory_index,
    };
    let texture_memory = device.allocate_memory(&texture_allocate_info).unwrap();
    device.bind_image_memory(texture_image, texture_memory, 0)
        .expect("Unable to bind depth image memory");

    device.begin_command_buffer(texture_command_buffer, &command_buffer_begin_info).unwrap();
    let texture_barrier = vk::ImageMemoryBarrier {
        s_type: vk::StructureType::ImageMemoryBarrier,
        p_next: ptr::null(),
        src_access_mask: Default::default(),
        dst_access_mask: vk::ACCESS_TRANSFER_WRITE_BIT,
        old_layout: vk::ImageLayout::Undefined,
        new_layout: vk::ImageLayout::TransferDstOptimal,
        src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED,
        dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED,
        image: texture_image,
        subresource_range: vk::ImageSubresourceRange {
            aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT,
            base_mip_level: 0,
            level_count: 1,
            base_array_layer: 0,
            layer_count: 1,
        },
    };
    device.cmd_pipeline_barrier(texture_command_buffer,
                                vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                vk::DependencyFlags::empty(),
                                &[],
                                &[],
                                &[texture_barrier]);
    let buffer_copy_regions = [vk::BufferImageCopy {
                                   image_subresource: vk::ImageSubresourceLayers {
                                       aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT,
                                       mip_level: 0,
                                       base_array_layer: 0,
                                       layer_count: 1,
                                   },
                                   image_extent: vk::Extent3D {
                                       width: image_dimensions.0,
                                       height: image_dimensions.1,
                                       depth: 1,
                                   },
                                   buffer_offset: 0,
                                   // FIX ME
                                   buffer_image_height: 0,
                                   buffer_row_length: 0,
                                   image_offset: vk::Offset3D { x: 0, y: 0, z: 0 },
                               }];
    device.cmd_copy_buffer_to_image(texture_command_buffer,
                                    image_buffer,
                                    texture_image,
                                    vk::ImageLayout::TransferDstOptimal,
                                    &buffer_copy_regions);
    let texture_barrier_end = vk::ImageMemoryBarrier {
        s_type: vk::StructureType::ImageMemoryBarrier,
        p_next: ptr::null(),
        src_access_mask: vk::ACCESS_TRANSFER_WRITE_BIT,
        dst_access_mask: vk::ACCESS_SHADER_READ_BIT,
        old_layout: vk::ImageLayout::TransferDstOptimal,
        new_layout: vk::ImageLayout::ShaderReadOnlyOptimal,
        src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED,
        dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED,
        image: texture_image,
        subresource_range: vk::ImageSubresourceRange {
            aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT,
            base_mip_level: 0,
            level_count: 1,
            base_array_layer: 0,
            layer_count: 1,
        },
    };
    device.cmd_pipeline_barrier(texture_command_buffer,
                                vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                vk::DependencyFlags::empty(),
                                &[],
                                &[],
                                &[texture_barrier_end]);
    let wait_stage_mask = [vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT];
    let texture_cb_fence = device.create_fence(&fence_create_info).unwrap();
    let tex_submit_info = vk::SubmitInfo {
        s_type: vk::StructureType::SubmitInfo,
        p_next: ptr::null(),
        wait_semaphore_count: 0,
        p_wait_semaphores: ptr::null(),
        signal_semaphore_count: 0,
        p_signal_semaphores: ptr::null(),
        p_wait_dst_stage_mask: wait_stage_mask.as_ptr(),
        command_buffer_count: 1,
        p_command_buffers: &texture_command_buffer,
    };
    device.end_command_buffer(texture_command_buffer).unwrap();
    device.queue_submit(present_queue, &[tex_submit_info], texture_cb_fence).unwrap();
    device.wait_for_fences(&[texture_cb_fence], true, std::u64::MAX).unwrap();

    let sampler_info = vk::SamplerCreateInfo{
        s_type: vk::StructureType::SamplerCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        mag_filter: vk::Filter::Linear,
        min_filter: vk::Filter::Linear,
        mipmap_mode: vk::SamplerMipmapMode::Linear,
        address_mode_u: vk::SamplerAddressMode::MirroredRepeat,
        address_mode_v: vk::SamplerAddressMode::MirroredRepeat,
        address_mode_w: vk::SamplerAddressMode::MirroredRepeat,
        mip_lod_bias: 0.0,
        min_lod: 0.0,
        max_lod: 0.0,
        anisotropy_enable: 0,
        max_anisotropy: 1.0,
        border_color: vk::BorderColor::FloatOpaqueWhite,
        compare_enable: 0,
        compare_op: vk::CompareOp::Never,
        unnormalized_coordinates: 0
    };

    let sampler = device.create_sampler(&sampler_info).unwrap();

    let tex_image_view_info = vk::ImageViewCreateInfo {
        s_type: vk::StructureType::ImageViewCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        view_type: vk::ImageViewType::Type2d,
        format: texture_create_info.format,
        components: vk::ComponentMapping {
            r: vk::ComponentSwizzle::R,
            g: vk::ComponentSwizzle::G,
            b: vk::ComponentSwizzle::B,
            a: vk::ComponentSwizzle::A,
        },
        subresource_range: vk::ImageSubresourceRange {
            aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT,
            base_mip_level: 0,
            level_count: 1,
            base_array_layer: 0,
            layer_count: 1,
        },
        image: texture_image,
    };
    let tex_image_view = device.create_image_view(&depth_image_view_info).unwrap();
    let descriptor_sizes = [vk::DescriptorPoolSize {
                                typ: vk::DescriptorType::UniformBuffer,
                                descriptor_count: 1,
                            },
                            vk::DescriptorPoolSize {
                                typ: vk::DescriptorType::CombinedImageSampler,
                                descriptor_count: 1,
                            }];
    let descriptor_pool_info = vk::DescriptorPoolCreateInfo {
        s_type: vk::StructureType::DescriptorPoolCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        pool_size_count: descriptor_sizes.len() as u32,
        p_pool_sizes: descriptor_sizes.as_ptr(),
        max_sets: 1,
    };
    let descriptor_pool = device.create_descriptor_pool(&descriptor_pool_info).unwrap();
    let desc_layout_bindings = [vk::DescriptorSetLayoutBinding {
                                    binding: 0,
                                    descriptor_type: vk::DescriptorType::UniformBuffer,
                                    descriptor_count: 1,
                                    stage_flags: vk::SHADER_STAGE_FRAGMENT_BIT,
                                    p_immutable_samplers: ptr::null(),
                                },
                                vk::DescriptorSetLayoutBinding {
                                    binding: 1,
                                    descriptor_type: vk::DescriptorType::CombinedImageSampler,
                                    descriptor_count: 1,
                                    stage_flags: vk::SHADER_STAGE_FRAGMENT_BIT,
                                    p_immutable_samplers: ptr::null(),
                                }];
    let descriptor_info = vk::DescriptorSetLayoutCreateInfo {
        s_type: vk::StructureType::DescriptorSetLayoutCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        binding_count: desc_layout_bindings.len() as u32,
        p_bindings: desc_layout_bindings.as_ptr(),
    };


    let desc_set_layouts = [device.create_descriptor_set_layout(&descriptor_info).unwrap()];
    let desc_alloc_info = vk::DescriptorSetAllocateInfo {
        s_type: vk::StructureType::DescriptorSetAllocateInfo,
        p_next: ptr::null(),
        descriptor_pool: descriptor_pool,
        descriptor_set_count: desc_set_layouts.len() as u32,
        p_set_layouts: desc_set_layouts.as_ptr(),
    };
    let descriptor_sets = device.allocate_descriptor_sets(&desc_alloc_info).unwrap();

    let uniform_color_buffer_descriptor = vk::DescriptorBufferInfo {
        buffer: uniform_color_buffer,
        offset: 0,
        range: mem::size_of_val(&uniform_color_buffer_data) as u64,
    };

    let tex_descriptor = vk::DescriptorImageInfo{
        image_layout: vk::ImageLayout::General,
        image_view: tex_image_view,
        sampler: sampler
    };

    let write_desc_sets = [vk::WriteDescriptorSet {
                               s_type: vk::StructureType::WriteDescriptorSet,
                               p_next: ptr::null(),
                               dst_set: descriptor_sets[0],
                               dst_binding: 0,
                               dst_array_element: 0,
                               descriptor_count: 1,
                               descriptor_type: vk::DescriptorType::UniformBuffer,
                               p_image_info: ptr::null(),
                               p_buffer_info: &uniform_color_buffer_descriptor,
                               p_texel_buffer_view: ptr::null(),
                           },vk::WriteDescriptorSet {
                               s_type: vk::StructureType::WriteDescriptorSet,
                               p_next: ptr::null(),
                               dst_set: descriptor_sets[0],
                               dst_binding: 1,
                               dst_array_element: 0,
                               descriptor_count: 1,
                               descriptor_type: vk::DescriptorType::CombinedImageSampler,
                               p_image_info: &tex_descriptor,
                               p_buffer_info: ptr::null(),
                               p_texel_buffer_view: ptr::null(),
                           }];
    device.update_descriptor_sets(&write_desc_sets[..], &[]);
    let vertex_spv_file = File::open(Path::new("shader/vert.spv"))
        .expect("Could not find vert.spv.");
    let frag_spv_file = File::open(Path::new("shader/frag.spv")).expect("Could not find frag.spv.");

    let vertex_bytes: Vec<u8> = vertex_spv_file.bytes().filter_map(|byte| byte.ok()).collect();
    let vertex_shader_info = vk::ShaderModuleCreateInfo {
        s_type: vk::StructureType::ShaderModuleCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        code_size: vertex_bytes.len(),
        p_code: vertex_bytes.as_ptr() as *const u32,
    };
    let frag_bytes: Vec<u8> = frag_spv_file.bytes().filter_map(|byte| byte.ok()).collect();
    let frag_shader_info = vk::ShaderModuleCreateInfo {
        s_type: vk::StructureType::ShaderModuleCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        code_size: frag_bytes.len(),
        p_code: frag_bytes.as_ptr() as *const u32,
    };
    let vertex_shader_module = device.create_shader_module(&vertex_shader_info)
        .expect("Vertex shader module error");

    let fragment_shader_module = device.create_shader_module(&frag_shader_info)
        .expect("Fragment shader module error");

    let layout_create_info = vk::PipelineLayoutCreateInfo {
        s_type: vk::StructureType::PipelineLayoutCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        set_layout_count: desc_set_layouts.len() as u32,
        p_set_layouts: desc_set_layouts.as_ptr(),
        push_constant_range_count: 0,
        p_push_constant_ranges: ptr::null(),
    };

    let pipeline_layout = device.create_pipeline_layout(&layout_create_info).unwrap();

    let shader_entry_name = CString::new("main").unwrap();
    let shader_stage_create_infos = [vk::PipelineShaderStageCreateInfo {
                                         s_type: vk::StructureType::PipelineShaderStageCreateInfo,
                                         p_next: ptr::null(),
                                         flags: Default::default(),
                                         module: vertex_shader_module,
                                         p_name: shader_entry_name.as_ptr(),
                                         p_specialization_info: ptr::null(),
                                         stage: vk::SHADER_STAGE_VERTEX_BIT,
                                     },
                                     vk::PipelineShaderStageCreateInfo {
                                         s_type: vk::StructureType::PipelineShaderStageCreateInfo,
                                         p_next: ptr::null(),
                                         flags: Default::default(),
                                         module: fragment_shader_module,
                                         p_name: shader_entry_name.as_ptr(),
                                         p_specialization_info: ptr::null(),
                                         stage: vk::SHADER_STAGE_FRAGMENT_BIT,
                                     }];
    let vertex_input_binding_descriptions = [vk::VertexInputBindingDescription {
                                                 binding: 0,
                                                 stride: mem::size_of::<Vertex>() as u32,
                                                 input_rate: vk::VertexInputRate::Vertex,
                                             }];
    let vertex_input_attribute_descriptions = [vk::VertexInputAttributeDescription {
                                                   location: 0,
                                                   binding: 0,
                                                   format: vk::Format::R32g32b32a32Sfloat,
                                                   offset: offset_of!(Vertex, pos) as u32,
                                               },
                                               vk::VertexInputAttributeDescription {
                                                   location: 1,
                                                   binding: 0,
                                                   format: vk::Format::R32g32Sfloat,
                                                   offset: offset_of!(Vertex, uv) as u32,
                                               }];
    let vertex_input_state_info = vk::PipelineVertexInputStateCreateInfo {
        s_type: vk::StructureType::PipelineVertexInputStateCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        vertex_attribute_description_count: vertex_input_attribute_descriptions.len() as u32,
        p_vertex_attribute_descriptions: vertex_input_attribute_descriptions.as_ptr(),
        vertex_binding_description_count: vertex_input_binding_descriptions.len() as u32,
        p_vertex_binding_descriptions: vertex_input_binding_descriptions.as_ptr(),
    };
    let vertex_input_assembly_state_info = vk::PipelineInputAssemblyStateCreateInfo {
        s_type: vk::StructureType::PipelineInputAssemblyStateCreateInfo,
        flags: Default::default(),
        p_next: ptr::null(),
        primitive_restart_enable: 0,
        topology: vk::PrimitiveTopology::TriangleList,
    };
    let viewports = [vk::Viewport {
                         x: 0.0,
                         y: 0.0,
                         width: surface_resoultion.width as f32,
                         height: surface_resoultion.height as f32,
                         min_depth: 0.0,
                         max_depth: 1.0,
                     }];
    let scissors = [vk::Rect2D {
                        offset: vk::Offset2D { x: 0, y: 0 },
                        extent: surface_resoultion.clone(),
                    }];
    let viewport_state_info = vk::PipelineViewportStateCreateInfo {
        s_type: vk::StructureType::PipelineViewportStateCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        scissor_count: scissors.len() as u32,
        p_scissors: scissors.as_ptr(),
        viewport_count: viewports.len() as u32,
        p_viewports: viewports.as_ptr(),
    };
    let rasterization_info = vk::PipelineRasterizationStateCreateInfo {
        s_type: vk::StructureType::PipelineRasterizationStateCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        cull_mode: vk::CULL_MODE_NONE,
        depth_bias_clamp: 0.0,
        depth_bias_constant_factor: 0.0,
        depth_bias_enable: 0,
        depth_bias_slope_factor: 0.0,
        depth_clamp_enable: 0,
        front_face: vk::FrontFace::CounterClockwise,
        line_width: 1.0,
        polygon_mode: vk::PolygonMode::Fill,
        rasterizer_discard_enable: 0,
    };
    let multisample_state_info = vk::PipelineMultisampleStateCreateInfo {
        s_type: vk::StructureType::PipelineMultisampleStateCreateInfo,
        flags: Default::default(),
        p_next: ptr::null(),
        rasterization_samples: vk::SAMPLE_COUNT_1_BIT,
        sample_shading_enable: 0,
        min_sample_shading: 0.0,
        p_sample_mask: ptr::null(),
        alpha_to_one_enable: 0,
        alpha_to_coverage_enable: 0,
    };
    let noop_stencil_state = vk::StencilOpState {
        fail_op: vk::StencilOp::Keep,
        pass_op: vk::StencilOp::Keep,
        depth_fail_op: vk::StencilOp::Keep,
        compare_op: vk::CompareOp::Always,
        compare_mask: 0,
        write_mask: 0,
        reference: 0,
    };
    let depth_state_info = vk::PipelineDepthStencilStateCreateInfo {
        s_type: vk::StructureType::PipelineDepthStencilStateCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        depth_test_enable: 1,
        depth_write_enable: 1,
        depth_compare_op: vk::CompareOp::LessOrEqual,
        depth_bounds_test_enable: 0,
        stencil_test_enable: 0,
        front: noop_stencil_state.clone(),
        back: noop_stencil_state.clone(),
        max_depth_bounds: 1.0,
        min_depth_bounds: 0.0,
    };
    let color_blend_attachment_states = [vk::PipelineColorBlendAttachmentState {
                                             blend_enable: 0,
                                             src_color_blend_factor: vk::BlendFactor::SrcColor,
                                             dst_color_blend_factor:
                                                 vk::BlendFactor::OneMinusDstColor,
                                             color_blend_op: vk::BlendOp::Add,
                                             src_alpha_blend_factor: vk::BlendFactor::Zero,
                                             dst_alpha_blend_factor: vk::BlendFactor::Zero,
                                             alpha_blend_op: vk::BlendOp::Add,
                                             color_write_mask: vk::ColorComponentFlags::all(),
                                         }];
    let color_blend_state = vk::PipelineColorBlendStateCreateInfo {
        s_type: vk::StructureType::PipelineColorBlendStateCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        logic_op_enable: 0,
        logic_op: vk::LogicOp::Clear,
        attachment_count: color_blend_attachment_states.len() as u32,
        p_attachments: color_blend_attachment_states.as_ptr(),
        blend_constants: [0.0, 0.0, 0.0, 0.0],
    };
    let dynamic_state = [vk::DynamicState::Viewport, vk::DynamicState::Scissor];
    let dynamic_state_info = vk::PipelineDynamicStateCreateInfo {
        s_type: vk::StructureType::PipelineDynamicStateCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
        dynamic_state_count: dynamic_state.len() as u32,
        p_dynamic_states: dynamic_state.as_ptr(),
    };
    let graphic_pipeline_info = vk::GraphicsPipelineCreateInfo {
        s_type: vk::StructureType::GraphicsPipelineCreateInfo,
        p_next: ptr::null(),
        flags: vk::PipelineCreateFlags::empty(),
        stage_count: shader_stage_create_infos.len() as u32,
        p_stages: shader_stage_create_infos.as_ptr(),
        p_vertex_input_state: &vertex_input_state_info,
        p_input_assembly_state: &vertex_input_assembly_state_info,
        p_tessellation_state: ptr::null(),
        p_viewport_state: &viewport_state_info,
        p_rasterization_state: &rasterization_info,
        p_multisample_state: &multisample_state_info,
        p_depth_stencil_state: &depth_state_info,
        p_color_blend_state: &color_blend_state,
        p_dynamic_state: &dynamic_state_info,
        layout: pipeline_layout,
        render_pass: renderpass,
        subpass: 0,
        base_pipeline_handle: vk::Pipeline::null(),
        base_pipeline_index: 0,
    };
    let graphics_pipelines =
        device.create_graphics_pipelines(vk::PipelineCache::null(), &[graphic_pipeline_info])
            .unwrap();

    let graphic_pipeline = graphics_pipelines[0];

    let semaphore_create_info = vk::SemaphoreCreateInfo {
        s_type: vk::StructureType::SemaphoreCreateInfo,
        p_next: ptr::null(),
        flags: Default::default(),
    };
    let present_complete_semaphore = device.create_semaphore(&semaphore_create_info).unwrap();
    let rendering_complete_semaphore = device.create_semaphore(&semaphore_create_info).unwrap();

    let draw_fence = device.create_fence(&fence_create_info).unwrap();
    while window.should_close() {
        glfw.poll_events();
        for (_, event) in glfw::flush_messages(&events) {
            handle_window_event(&mut window, event);
        }
        let present_index = device.acquire_next_image_khr(swapchain,
                                    std::u64::MAX,
                                    present_complete_semaphore,
                                    vk::Fence::null())
            .unwrap();
        device.reset_command_buffer(draw_command_buffer, Default::default()).unwrap();
        device.begin_command_buffer(draw_command_buffer, &command_buffer_begin_info).unwrap();
        let clear_values =
            [vk::ClearValue::new_color(vk::ClearColorValue::new_float32([0.0, 0.0, 0.0, 0.0])),
             vk::ClearValue::new_depth_stencil(vk::ClearDepthStencilValue {
                 depth: 1.0,
                 stencil: 0,
             })];

        let render_pass_begin_info = vk::RenderPassBeginInfo {
            s_type: vk::StructureType::RenderPassBeginInfo,
            p_next: ptr::null(),
            render_pass: renderpass,
            framebuffer: framebuffers[present_index as usize],
            render_area: vk::Rect2D {
                offset: vk::Offset2D { x: 0, y: 0 },
                extent: surface_resoultion.clone(),
            },
            clear_value_count: clear_values.len() as u32,
            p_clear_values: clear_values.as_ptr(),
        };
        device.cmd_begin_render_pass(draw_command_buffer,
                                     &render_pass_begin_info,
                                     vk::SubpassContents::Inline);
        device.cmd_bind_pipeline(draw_command_buffer,
                                 vk::PipelineBindPoint::Graphics,
                                 graphic_pipeline);
        device.cmd_bind_descriptor_sets(draw_command_buffer,
                                        vk::PipelineBindPoint::Graphics,
                                        pipeline_layout,
                                        0,
                                        &descriptor_sets[..],
                                        &[]);
        device.cmd_set_viewport(draw_command_buffer, &viewports);
        device.cmd_set_scissor(draw_command_buffer, &scissors);
        device.cmd_bind_vertex_buffers(draw_command_buffer, &[vertex_input_buffer], &0);
        device.cmd_bind_index_buffer(draw_command_buffer, index_buffer, 0, vk::IndexType::Uint32);
        device.cmd_draw_indexed(draw_command_buffer,
                                index_buffer_data.len() as u32,
                                1,
                                0,
                                0,
                                1);
        // Or draw without the index buffer
        // device.cmd_draw(draw_command_buffer, 3, 1, 0, 0);
        device.cmd_end_render_pass(draw_command_buffer);
        device.end_command_buffer(draw_command_buffer).unwrap();
        let wait_render_mask = [vk::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT];
        let submit_info = vk::SubmitInfo {
            s_type: vk::StructureType::SubmitInfo,
            p_next: ptr::null(),
            wait_semaphore_count: 1,
            p_wait_semaphores: &present_complete_semaphore,
            p_wait_dst_stage_mask: wait_render_mask.as_ptr(),
            command_buffer_count: 1,
            p_command_buffers: &draw_command_buffer,
            signal_semaphore_count: 1,
            p_signal_semaphores: &rendering_complete_semaphore,
        };
        device.queue_submit(present_queue, &[submit_info], draw_fence)
            .unwrap();
        let mut present_info_err = unsafe { mem::uninitialized() };
        let present_info = vk::PresentInfoKHR {
            s_type: vk::StructureType::PresentInfoKhr,
            p_next: ptr::null(),
            wait_semaphore_count: 1,
            p_wait_semaphores: &rendering_complete_semaphore,
            swapchain_count: 1,
            p_swapchains: &swapchain,
            p_image_indices: &present_index,
            p_results: &mut present_info_err,
        };
        device.queue_present_khr(present_queue, &present_info).unwrap();
        device.wait_for_fences(&[draw_fence], true, std::u64::MAX)
            .unwrap();
        device.reset_fences(&[draw_fence]).unwrap();
    }

    device.device_wait_idle().unwrap();
    device.destroy_semaphore(present_complete_semaphore);
    device.destroy_semaphore(rendering_complete_semaphore);
    for pipeline in graphics_pipelines {
        device.destroy_pipeline(pipeline);
    }
    device.destroy_pipeline_layout(pipeline_layout);
    device.destroy_shader_module(vertex_shader_module);
    device.destroy_shader_module(fragment_shader_module);
    device.free_memory(index_buffer_memory);
    device.destroy_buffer(index_buffer);
    device.free_memory(vertex_input_buffer_memory);
    device.destroy_buffer(uniform_color_buffer);
    device.free_memory(uniform_color_buffer_memory);
    device.destroy_buffer(vertex_input_buffer);
    for framebuffer in framebuffers {
        device.destroy_framebuffer(framebuffer);
    }
    device.destroy_render_pass(renderpass);
    device.destroy_image_view(depth_image_view);
    device.destroy_fence(submit_fence);
    device.destroy_fence(draw_fence);
    device.destroy_fence(texture_cb_fence);
    device.free_memory(depth_image_memory);
    device.free_memory(texture_memory);
    device.free_memory(image_buffer_memory);
    device.destroy_image(depth_image);
    device.destroy_image(texture_image);
    device.destroy_buffer(image_buffer);
    for image_view in present_image_views {
        device.destroy_image_view(image_view);
    }
    for &layout in desc_set_layouts.iter() {
        device.destroy_descriptor_set_layout(layout);
    }
    device.destroy_descriptor_pool(descriptor_pool);
    device.destroy_command_pool(pool);
    device.destroy_swapchain_khr(swapchain);
    device.destroy_device();
    instance.destroy_surface_khr(surface);
    instance.destroy_debug_report_callback_ext(debug_call_back);
    instance.destroy_instance();
}