#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(dead_code)]

#[macro_use]
extern crate bitflags;
extern crate libc;
extern crate shared_library;

use self::libc::{c_void, c_char, uint32_t, size_t, uint64_t, c_float, int32_t, uint8_t};
use self::shared_library::dynamic_library::DynamicLibrary;
use std::path::{Path};
use std::ffi::CString;

#[macro_export]
macro_rules! VK_MAKE_VERSION {
    ($major:expr, $minor:expr, $patch:expr) => ((($major) << 22) | (($minor) << 12) | ($patch));
}

pub const VK_API_VERSION_1_0: uint32_t = VK_MAKE_VERSION!(1,0,0);

#[macro_export]
macro_rules! VK_VERSION_MAJOR {
    ($version:expr) => ($version >> 22);
}

#[macro_export]
macro_rules! VK_VERSION_MINOR {
    ($version:expr) => (($version >> 12) & 0x3ff);
}

#[macro_export]
macro_rules! VK_VERSION_PATCH {
    ($version:expr) => ($version & 0xfff);
}

#[macro_export]
macro_rules! VK_DEFINE_NON_DISPATCHABLE_HANDLE {
    ($name:ident) => (
        #[derive(Clone)] 
        #[derive(Copy)] 
        #[repr(C)]
        pub struct $name(uint64_t);
        impl $name {
            pub fn null() -> $name {
            $name(0)
            }
        }
    );
}

#[macro_export]
macro_rules! VK_DEFINE_HANDLE {
    ($name:ident) => (
        #[derive(Clone)] 
        #[derive(Copy)] 
        #[repr(C)]
        pub struct $name(*const c_void);
        impl $name {
            pub fn null() -> $name {
                $name(std::ptr::null())
            }
        }
    );
}

pub type VkFlags = uint32_t;
pub type VkBool32 = uint32_t;
pub type VkDeviceSize = uint64_t;
pub type VkSampleMask = uint32_t;

VK_DEFINE_HANDLE!(VkInstance);
VK_DEFINE_HANDLE!(VkPhysicalDevice);
VK_DEFINE_HANDLE!(VkDevice);
VK_DEFINE_HANDLE!(VkQueue);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkSemaphore);
VK_DEFINE_HANDLE!(VkCommandBuffer);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkFence);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkDeviceMemory);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkBuffer);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkImage);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkEvent);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkQueryPool);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkBufferView);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkImageView);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkShaderModule);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkPipelineCache);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkPipelineLayout);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkRenderPass);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkPipeline);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkDescriptorSetLayout);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkSampler);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkDescriptorPool);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkDescriptorSet);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkFramebuffer);
VK_DEFINE_NON_DISPATCHABLE_HANDLE!(VkCommandPool);

pub const VK_LOD_CLAMP_NONE:c_float = 1000.0f32;
pub const VK_REMAINING_MIP_LEVELS:uint32_t = !0x0u32;
pub const VK_REMAINING_ARRAY_LAYERS:uint32_t = !0x0u32;
pub const VK_WHOLE_SIZE:uint64_t = !0x0u64;
pub const VK_ATTACHMENT_UNUSED:uint32_t = !0x0u32;
pub const VK_TRUE:uint32_t = 1u32;
pub const VK_FALSE:uint32_t = 0u32;
pub const VK_QUEUE_FAMILY_IGNORED:uint32_t = !0x0u32;
pub const VK_SUBPASS_EXTERNAL:uint32_t = !0x0u32;
pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE:size_t = 256usize;
pub const VK_UUID_SIZE:size_t = 16usize;
pub const VK_MAX_MEMORY_TYPES:size_t = 32usize;
pub const VK_MAX_MEMORY_HEAPS:size_t = 16usize;
pub const VK_MAX_EXTENSION_NAME_SIZE:size_t = 256usize;
pub const VK_MAX_DESCRIPTION_SIZE:size_t = 256usize;

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkPipelineCacheHeaderVersion {
    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1
}

#[repr(i32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkResult {
    VK_SUCCESS = 0,
    VK_NOT_READY = 1,
    VK_TIMEOUT = 2,
    VK_EVENT_SET = 3,
    VK_EVENT_RESET = 4,
    VK_INCOMPLETE = 5,
    VK_ERROR_OUT_OF_HOST_MEMORY = -1,
    VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
    VK_ERROR_INITIALIZATION_FAILED = -3,
    VK_ERROR_DEVICE_LOST = -4,
    VK_ERROR_MEMORY_MAP_FAILED = -5,
    VK_ERROR_LAYER_NOT_PRESENT = -6,
    VK_ERROR_EXTENSION_NOT_PRESENT = -7,
    VK_ERROR_FEATURE_NOT_PRESENT = -8,
    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
    VK_ERROR_TOO_MANY_OBJECTS = -10,
    VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
    //VK_ERROR_SURFACE_LOST_KHR = -1000000000,
    //VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
    //VK_SUBOPTIMAL_KHR = 1000001003,
    //VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
    //VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
    //VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
    //VK_ERROR_INVALID_SHADER_NV = -1000012000
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkStructureType {
    VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
    VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
    VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
    VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
    VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
    VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
    VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
    VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
    VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
    VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
    VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
    VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
    VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
    //VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
    //VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
    //VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
    //VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
    //VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
    //VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
    //VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
    //VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
    //VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
    //VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
    //VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
    //VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
    //VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
    //VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
    //VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
    //VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkSystemAllocationScope {
    VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
    VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkInternalAllocationType {
    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkFormat {
    VK_FORMAT_UNDEFINED = 0,
    VK_FORMAT_R4G4_UNORM_PACK8 = 1,
    VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
    VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
    VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
    VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
    VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
    VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
    VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
    VK_FORMAT_R8_UNORM = 9,
    VK_FORMAT_R8_SNORM = 10,
    VK_FORMAT_R8_USCALED = 11,
    VK_FORMAT_R8_SSCALED = 12,
    VK_FORMAT_R8_UINT = 13,
    VK_FORMAT_R8_SINT = 14,
    VK_FORMAT_R8_SRGB = 15,
    VK_FORMAT_R8G8_UNORM = 16,
    VK_FORMAT_R8G8_SNORM = 17,
    VK_FORMAT_R8G8_USCALED = 18,
    VK_FORMAT_R8G8_SSCALED = 19,
    VK_FORMAT_R8G8_UINT = 20,
    VK_FORMAT_R8G8_SINT = 21,
    VK_FORMAT_R8G8_SRGB = 22,
    VK_FORMAT_R8G8B8_UNORM = 23,
    VK_FORMAT_R8G8B8_SNORM = 24,
    VK_FORMAT_R8G8B8_USCALED = 25,
    VK_FORMAT_R8G8B8_SSCALED = 26,
    VK_FORMAT_R8G8B8_UINT = 27,
    VK_FORMAT_R8G8B8_SINT = 28,
    VK_FORMAT_R8G8B8_SRGB = 29,
    VK_FORMAT_B8G8R8_UNORM = 30,
    VK_FORMAT_B8G8R8_SNORM = 31,
    VK_FORMAT_B8G8R8_USCALED = 32,
    VK_FORMAT_B8G8R8_SSCALED = 33,
    VK_FORMAT_B8G8R8_UINT = 34,
    VK_FORMAT_B8G8R8_SINT = 35,
    VK_FORMAT_B8G8R8_SRGB = 36,
    VK_FORMAT_R8G8B8A8_UNORM = 37,
    VK_FORMAT_R8G8B8A8_SNORM = 38,
    VK_FORMAT_R8G8B8A8_USCALED = 39,
    VK_FORMAT_R8G8B8A8_SSCALED = 40,
    VK_FORMAT_R8G8B8A8_UINT = 41,
    VK_FORMAT_R8G8B8A8_SINT = 42,
    VK_FORMAT_R8G8B8A8_SRGB = 43,
    VK_FORMAT_B8G8R8A8_UNORM = 44,
    VK_FORMAT_B8G8R8A8_SNORM = 45,
    VK_FORMAT_B8G8R8A8_USCALED = 46,
    VK_FORMAT_B8G8R8A8_SSCALED = 47,
    VK_FORMAT_B8G8R8A8_UINT = 48,
    VK_FORMAT_B8G8R8A8_SINT = 49,
    VK_FORMAT_B8G8R8A8_SRGB = 50,
    VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
    VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
    VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
    VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
    VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
    VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
    VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
    VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
    VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
    VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
    VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
    VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
    VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
    VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
    VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
    VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
    VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
    VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
    VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
    VK_FORMAT_R16_UNORM = 70,
    VK_FORMAT_R16_SNORM = 71,
    VK_FORMAT_R16_USCALED = 72,
    VK_FORMAT_R16_SSCALED = 73,
    VK_FORMAT_R16_UINT = 74,
    VK_FORMAT_R16_SINT = 75,
    VK_FORMAT_R16_SFLOAT = 76,
    VK_FORMAT_R16G16_UNORM = 77,
    VK_FORMAT_R16G16_SNORM = 78,
    VK_FORMAT_R16G16_USCALED = 79,
    VK_FORMAT_R16G16_SSCALED = 80,
    VK_FORMAT_R16G16_UINT = 81,
    VK_FORMAT_R16G16_SINT = 82,
    VK_FORMAT_R16G16_SFLOAT = 83,
    VK_FORMAT_R16G16B16_UNORM = 84,
    VK_FORMAT_R16G16B16_SNORM = 85,
    VK_FORMAT_R16G16B16_USCALED = 86,
    VK_FORMAT_R16G16B16_SSCALED = 87,
    VK_FORMAT_R16G16B16_UINT = 88,
    VK_FORMAT_R16G16B16_SINT = 89,
    VK_FORMAT_R16G16B16_SFLOAT = 90,
    VK_FORMAT_R16G16B16A16_UNORM = 91,
    VK_FORMAT_R16G16B16A16_SNORM = 92,
    VK_FORMAT_R16G16B16A16_USCALED = 93,
    VK_FORMAT_R16G16B16A16_SSCALED = 94,
    VK_FORMAT_R16G16B16A16_UINT = 95,
    VK_FORMAT_R16G16B16A16_SINT = 96,
    VK_FORMAT_R16G16B16A16_SFLOAT = 97,
    VK_FORMAT_R32_UINT = 98,
    VK_FORMAT_R32_SINT = 99,
    VK_FORMAT_R32_SFLOAT = 100,
    VK_FORMAT_R32G32_UINT = 101,
    VK_FORMAT_R32G32_SINT = 102,
    VK_FORMAT_R32G32_SFLOAT = 103,
    VK_FORMAT_R32G32B32_UINT = 104,
    VK_FORMAT_R32G32B32_SINT = 105,
    VK_FORMAT_R32G32B32_SFLOAT = 106,
    VK_FORMAT_R32G32B32A32_UINT = 107,
    VK_FORMAT_R32G32B32A32_SINT = 108,
    VK_FORMAT_R32G32B32A32_SFLOAT = 109,
    VK_FORMAT_R64_UINT = 110,
    VK_FORMAT_R64_SINT = 111,
    VK_FORMAT_R64_SFLOAT = 112,
    VK_FORMAT_R64G64_UINT = 113,
    VK_FORMAT_R64G64_SINT = 114,
    VK_FORMAT_R64G64_SFLOAT = 115,
    VK_FORMAT_R64G64B64_UINT = 116,
    VK_FORMAT_R64G64B64_SINT = 117,
    VK_FORMAT_R64G64B64_SFLOAT = 118,
    VK_FORMAT_R64G64B64A64_UINT = 119,
    VK_FORMAT_R64G64B64A64_SINT = 120,
    VK_FORMAT_R64G64B64A64_SFLOAT = 121,
    VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
    VK_FORMAT_D16_UNORM = 124,
    VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
    VK_FORMAT_D32_SFLOAT = 126,
    VK_FORMAT_S8_UINT = 127,
    VK_FORMAT_D16_UNORM_S8_UINT = 128,
    VK_FORMAT_D24_UNORM_S8_UINT = 129,
    VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
    VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
    VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
    VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
    VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
    VK_FORMAT_BC2_UNORM_BLOCK = 135,
    VK_FORMAT_BC2_SRGB_BLOCK = 136,
    VK_FORMAT_BC3_UNORM_BLOCK = 137,
    VK_FORMAT_BC3_SRGB_BLOCK = 138,
    VK_FORMAT_BC4_UNORM_BLOCK = 139,
    VK_FORMAT_BC4_SNORM_BLOCK = 140,
    VK_FORMAT_BC5_UNORM_BLOCK = 141,
    VK_FORMAT_BC5_SNORM_BLOCK = 142,
    VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
    VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
    VK_FORMAT_BC7_UNORM_BLOCK = 145,
    VK_FORMAT_BC7_SRGB_BLOCK = 146,
    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
    VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
    VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
    VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
    VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
    VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
    VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
    VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
    VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
    VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
    VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
    VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
    VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
    VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
    VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
    VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
    VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
    VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
    VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
    VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
    VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
    VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
    VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
    VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
    VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
    VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
    VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
    VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
    VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
    VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
    VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
    VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
    VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkImageType {
    VK_IMAGE_TYPE_1D = 0,
    VK_IMAGE_TYPE_2D = 1,
    VK_IMAGE_TYPE_3D = 2
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkImageTiling {
    VK_IMAGE_TILING_OPTIMAL = 0,
    VK_IMAGE_TILING_LINEAR = 1
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkPhysicalDeviceType {
    VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
    VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
    VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
    VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
    VK_PHYSICAL_DEVICE_TYPE_CPU = 4
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkQueryType {
    VK_QUERY_TYPE_OCCLUSION = 0,
    VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
    VK_QUERY_TYPE_TIMESTAMP = 2
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkSharingMode {
    VK_SHARING_MODE_EXCLUSIVE = 0,
    VK_SHARING_MODE_CONCURRENT = 1
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkImageLayout {
    VK_IMAGE_LAYOUT_UNDEFINED = 0,
    VK_IMAGE_LAYOUT_GENERAL = 1,
    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
    VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
    //VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkImageViewType {
    VK_IMAGE_VIEW_TYPE_1D = 0,
    VK_IMAGE_VIEW_TYPE_2D = 1,
    VK_IMAGE_VIEW_TYPE_3D = 2,
    VK_IMAGE_VIEW_TYPE_CUBE = 3,
    VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
    VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkComponentSwizzle {
    VK_COMPONENT_SWIZZLE_IDENTITY = 0,
    VK_COMPONENT_SWIZZLE_ZERO = 1,
    VK_COMPONENT_SWIZZLE_ONE = 2,
    VK_COMPONENT_SWIZZLE_R = 3,
    VK_COMPONENT_SWIZZLE_G = 4,
    VK_COMPONENT_SWIZZLE_B = 5,
    VK_COMPONENT_SWIZZLE_A = 6
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkVertexInputRate {
    VK_VERTEX_INPUT_RATE_VERTEX = 0,
    VK_VERTEX_INPUT_RATE_INSTANCE = 1
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkPrimitiveTopology {
    VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
    VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
    VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkPolygonMode {
    VK_POLYGON_MODE_FILL = 0,
    VK_POLYGON_MODE_LINE = 1,
    VK_POLYGON_MODE_POINT = 2
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkFrontFace {
    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
    VK_FRONT_FACE_CLOCKWISE = 1
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkCompareOp {
    VK_COMPARE_OP_NEVER = 0,
    VK_COMPARE_OP_LESS = 1,
    VK_COMPARE_OP_EQUAL = 2,
    VK_COMPARE_OP_LESS_OR_EQUAL = 3,
    VK_COMPARE_OP_GREATER = 4,
    VK_COMPARE_OP_NOT_EQUAL = 5,
    VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
    VK_COMPARE_OP_ALWAYS = 7
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkStencilOp {
    VK_STENCIL_OP_KEEP = 0,
    VK_STENCIL_OP_ZERO = 1,
    VK_STENCIL_OP_REPLACE = 2,
    VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
    VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
    VK_STENCIL_OP_INVERT = 5,
    VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
    VK_STENCIL_OP_DECREMENT_AND_WRAP = 7
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkLogicOp {
    VK_LOGIC_OP_CLEAR = 0,
    VK_LOGIC_OP_AND = 1,
    VK_LOGIC_OP_AND_REVERSE = 2,
    VK_LOGIC_OP_COPY = 3,
    VK_LOGIC_OP_AND_INVERTED = 4,
    VK_LOGIC_OP_NO_OP = 5,
    VK_LOGIC_OP_XOR = 6,
    VK_LOGIC_OP_OR = 7,
    VK_LOGIC_OP_NOR = 8,
    VK_LOGIC_OP_EQUIVALENT = 9,
    VK_LOGIC_OP_INVERT = 10,
    VK_LOGIC_OP_OR_REVERSE = 11,
    VK_LOGIC_OP_COPY_INVERTED = 12,
    VK_LOGIC_OP_OR_INVERTED = 13,
    VK_LOGIC_OP_NAND = 14,
    VK_LOGIC_OP_SET = 15
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkBlendFactor {
    VK_BLEND_FACTOR_ZERO = 0,
    VK_BLEND_FACTOR_ONE = 1,
    VK_BLEND_FACTOR_SRC_COLOR = 2,
    VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
    VK_BLEND_FACTOR_DST_COLOR = 4,
    VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
    VK_BLEND_FACTOR_SRC_ALPHA = 6,
    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
    VK_BLEND_FACTOR_DST_ALPHA = 8,
    VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
    VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
    VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
    VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
    VK_BLEND_FACTOR_SRC1_COLOR = 15,
    VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
    VK_BLEND_FACTOR_SRC1_ALPHA = 17,
    VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkBlendOp {
    VK_BLEND_OP_ADD = 0,
    VK_BLEND_OP_SUBTRACT = 1,
    VK_BLEND_OP_REVERSE_SUBTRACT = 2,
    VK_BLEND_OP_MIN = 3,
    VK_BLEND_OP_MAX = 4
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkDynamicState {
    VK_DYNAMIC_STATE_VIEWPORT = 0,
    VK_DYNAMIC_STATE_SCISSOR = 1,
    VK_DYNAMIC_STATE_LINE_WIDTH = 2,
    VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
    VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
    VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
    VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
    VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
    VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkFilter {
    VK_FILTER_NEAREST = 0,
    VK_FILTER_LINEAR = 1,
    //VK_FILTER_CUBIC_IMG = 1000015000
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkSamplerMipmapMode {
    VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkSamplerAddressMode {
    VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkBorderColor {
    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
    VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
    VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
    VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
    VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
    VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkDescriptorType {
    VK_DESCRIPTOR_TYPE_SAMPLER = 0,
    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
    VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
    VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
    VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkAttachmentLoadOp {
    VK_ATTACHMENT_LOAD_OP_LOAD = 0,
    VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
    VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkAttachmentStoreOp {
    VK_ATTACHMENT_STORE_OP_STORE = 0,
    VK_ATTACHMENT_STORE_OP_DONT_CARE = 1
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkPipelineBindPoint {
    VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
    VK_PIPELINE_BIND_POINT_COMPUTE = 1
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkCommandBufferLevel {
    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkIndexType {
    VK_INDEX_TYPE_UINT16 = 0,
    VK_INDEX_TYPE_UINT32 = 1
}

#[repr(u32)]
#[derive(Eq)]
#[derive(PartialEq)]
#[derive(Debug)]
pub enum VkSubpassContents {
    VK_SUBPASS_CONTENTS_INLINE = 0,
    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1
}

pub type VkInstanceCreateFlags = VkFlags;

bitflags! {
    pub flags VkFormatFeatureFlagBits: VkFlags {
        const VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
        const VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
        const VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
        const VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
        const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
        const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
        const VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
        const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
        const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
        const VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
        const VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
        const VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
        const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
        const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000
    }
}
pub type VkFormatFeatureFlags = VkFlags;

bitflags! {
    pub flags VkImageUsageFlagBits: VkFlags {
        const VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
        const VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
        const VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
        const VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
        const VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
        const VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
        const VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
        const VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080
    }
}
pub type VkImageUsageFlags = VkFlags;

bitflags! {
    pub flags VkImageCreateFlagBits: VkFlags {
        const VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
        const VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
        const VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
        const VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
        const VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010
    }
}
pub type VkImageCreateFlags = VkFlags;

bitflags! {
    pub flags VkSampleCountFlagBits: VkFlags {
        const VK_SAMPLE_COUNT_1_BIT = 0x00000001,
        const VK_SAMPLE_COUNT_2_BIT = 0x00000002,
        const VK_SAMPLE_COUNT_4_BIT = 0x00000004,
        const VK_SAMPLE_COUNT_8_BIT = 0x00000008,
        const VK_SAMPLE_COUNT_16_BIT = 0x00000010,
        const VK_SAMPLE_COUNT_32_BIT = 0x00000020,
        const VK_SAMPLE_COUNT_64_BIT = 0x00000040
    }
}
pub type VkSampleCountFlags = VkFlags;

bitflags! {
    pub flags VkQueueFlagBits: VkFlags {
        const VK_QUEUE_GRAPHICS_BIT = 0x00000001,
        const VK_QUEUE_COMPUTE_BIT = 0x00000002,
        const VK_QUEUE_TRANSFER_BIT = 0x00000004,
        const VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008
    }
}
pub type VkQueueFlags = VkFlags;

bitflags! {
    pub flags VkMemoryPropertyFlagBits: VkFlags {
        const VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
        const VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
        const VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
        const VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
        const VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010
    }
}
pub type VkMemoryPropertyFlags = VkFlags;

bitflags! {
    pub flags VkMemoryHeapFlagBits: VkFlags {
        const VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001
    }
}
pub type VkMemoryHeapFlags = VkFlags;

pub type VkDeviceCreateFlags = VkFlags;
pub type VkDeviceQueueCreateFlags = VkFlags;

bitflags! {
    pub flags VkPipelineStageFlagBits: VkFlags {
        const VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
        const VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
        const VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
        const VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
        const VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
        const VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
        const VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
        const VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
        const VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
        const VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
        const VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
        const VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
        const VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
        const VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
        const VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
        const VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
        const VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000
    }
}
pub type VkPipelineStageFlags = VkFlags;

pub type VkMemoryMapFlags = VkFlags;

bitflags! {
    pub flags VkImageAspectFlagBits: VkFlags {
        const VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
        const VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
        const VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
        const VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008
    }
}
pub type VkImageAspectFlags = VkFlags;

bitflags! {
    pub flags VkSparseImageFormatFlagBits: VkFlags {
        const VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
        const VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
        const VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004
    }
}
pub type VkSparseImageFormatFlags = VkFlags;

bitflags! {
    pub flags VkSparseMemoryBindFlagBits: VkFlags {
        const VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001
    }
}
pub type VkSparseMemoryBindFlags = VkFlags;

bitflags! {
    pub flags VkFenceCreateFlagBits: VkFlags {
        const VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001
    }
}
pub type VkFenceCreateFlags = VkFlags;

pub type VkSemaphoreCreateFlags = VkFlags;
pub type VkEventCreateFlags = VkFlags;
pub type VkQueryPoolCreateFlags = VkFlags;

bitflags! {
    pub flags VkQueryPipelineStatisticFlagBits: VkFlags {
        const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
        const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
        const VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
        const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
        const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
        const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
        const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
        const VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
        const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
        const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
        const VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400
    }
}
pub type VkQueryPipelineStatisticFlags = VkFlags;

bitflags! {
    pub flags VkQueryResultFlagBits: VkFlags {
        const VK_QUERY_RESULT_64_BIT = 0x00000001,
        const VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
        const VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
        const VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008
    }
}
pub type VkQueryResultFlags = VkFlags;

bitflags! {
    pub flags VkBufferCreateFlagBits: VkFlags {
        const VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
        const VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
        const VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004
    }
}
pub type VkBufferCreateFlags = VkFlags;

bitflags! {
    pub flags VkBufferUsageFlagBits: VkFlags {
        const VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
        const VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
        const VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
        const VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
        const VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
        const VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
        const VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
        const VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
        const VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100
    }
}
pub type VkBufferUsageFlags = VkFlags;

pub type VkBufferViewCreateFlags = VkFlags;
pub type VkImageViewCreateFlags = VkFlags;
pub type VkShaderModuleCreateFlags = VkFlags;
pub type VkPipelineCacheCreateFlags = VkFlags;

bitflags! {
    pub flags VkPipelineCreateFlagBits: VkFlags {
        const VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
        const VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
        const VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004
    }
}
pub type VkPipelineCreateFlags = VkFlags;

pub type VkPipelineShaderStageCreateFlags = VkFlags;

bitflags! {
    pub flags VkShaderStageFlagBits: VkFlags {
        const VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
        const VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
        const VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
        const VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
        const VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
        const VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
        const VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
        const VK_SHADER_STAGE_ALL = 0x7FFFFFFF
    }
}
pub type VkShaderStageFlags = VkFlags;

pub type VkPipelineVertexInputStateCreateFlags = VkFlags;
pub type VkPipelineInputAssemblyStateCreateFlags = VkFlags;
pub type VkPipelineTessellationStateCreateFlags = VkFlags;
pub type VkPipelineViewportStateCreateFlags = VkFlags;
pub type VkPipelineRasterizationStateCreateFlags = VkFlags;

bitflags! {
    pub flags VkCullModeFlagBits: VkFlags {
        const VK_CULL_MODE_NONE = 0,
        const VK_CULL_MODE_FRONT_BIT = 0x00000001,
        const VK_CULL_MODE_BACK_BIT = 0x00000002,
        const VK_CULL_MODE_FRONT_AND_BACK = 0x00000003
    }
}
pub type VkCullModeFlags = VkFlags;

pub type VkPipelineMultisampleStateCreateFlags = VkFlags;
pub type VkPipelineDepthStencilStateCreateFlags = VkFlags;
pub type VkPipelineColorBlendStateCreateFlags = VkFlags;

bitflags! {
    pub flags VkColorComponentFlagBits: VkFlags {
        const VK_COLOR_COMPONENT_R_BIT = 0x00000001,
        const VK_COLOR_COMPONENT_G_BIT = 0x00000002,
        const VK_COLOR_COMPONENT_B_BIT = 0x00000004,
        const VK_COLOR_COMPONENT_A_BIT = 0x00000008
    }
}
pub type VkColorComponentFlags = VkFlags;

pub type VkPipelineDynamicStateCreateFlags = VkFlags;
pub type VkPipelineLayoutCreateFlags = VkFlags;
pub type VkSamplerCreateFlags = VkFlags;
pub type VkDescriptorSetLayoutCreateFlags = VkFlags;

bitflags! {
    pub flags VkDescriptorPoolCreateFlagBits: VkFlags {
        const VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001
    }
}
pub type VkDescriptorPoolCreateFlags = VkFlags;

pub type VkDescriptorPoolResetFlags = VkFlags;
pub type VkFramebufferCreateFlags = VkFlags;
pub type VkRenderPassCreateFlags = VkFlags;

bitflags! {
    pub flags VkAttachmentDescriptionFlagBits: VkFlags {
        const VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001
    }
}
pub type VkAttachmentDescriptionFlags = VkFlags;

pub type VkSubpassDescriptionFlags = VkFlags;

bitflags! {
    pub flags VkAccessFlagBits: VkFlags {
        const VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
        const VK_ACCESS_INDEX_READ_BIT = 0x00000002,
        const VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
        const VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
        const VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
        const VK_ACCESS_SHADER_READ_BIT = 0x00000020,
        const VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
        const VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
        const VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
        const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
        const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
        const VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
        const VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
        const VK_ACCESS_HOST_READ_BIT = 0x00002000,
        const VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
        const VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
        const VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000
    }
}
pub type VkAccessFlags = VkFlags;

bitflags! {
    pub flags VkDependencyFlagBits: VkFlags {
        const VK_DEPENDENCY_BY_REGION_BIT = 0x00000001
    }
}
pub type VkDependencyFlags = VkFlags;

bitflags! {
    pub flags VkCommandPoolCreateFlagBits: VkFlags {
        const VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
        const VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002
    }
}
pub type VkCommandPoolCreateFlags = VkFlags;

bitflags! {
    pub flags VkCommandPoolResetFlagBits: VkFlags {
        const VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001
    }
}
pub type VkCommandPoolResetFlags = VkFlags;

bitflags! {
    pub flags VkCommandBufferUsageFlagBits: VkFlags {
        const VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
        const VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
        const VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004
    }
}
pub type VkCommandBufferUsageFlags = VkFlags;

bitflags! {
    pub flags VkQueryControlFlagBits: VkFlags {
        const VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001
    }
}
pub type VkQueryControlFlags = VkFlags;

bitflags! {
    pub flags VkCommandBufferResetFlagBits: VkFlags {
        const VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001
    }
}
pub type VkCommandBufferResetFlags = VkFlags;

bitflags! {
    pub flags VkStencilFaceFlagBits: VkFlags {
        const VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
        const VK_STENCIL_FACE_BACK_BIT = 0x00000002,
        const VK_STENCIL_FRONT_AND_BACK = 0x00000003
    }
}
pub type VkStencilFaceFlags = VkFlags;

pub type vkAllocationFunctionFn = unsafe extern "stdcall" fn(pUserData: *mut c_void,
                                                             size: size_t,
                                                             alignment: size_t,
                                                             allocationScope: VkSystemAllocationScope);

pub type vkReallocationFunctionFn = unsafe extern "stdcall" fn(pUserData: *mut c_void,
                                                               pOriginal: *mut c_void,
                                                               size: size_t,
                                                               alignment: size_t,
                                                               allocationScope: VkSystemAllocationScope);

pub type vkFreeFunctionFn = unsafe extern "stdcall" fn(pUserData: *mut c_void,
                                                       pMemory: *mut c_void);

pub type vkInternalAllocationNotificationFn = unsafe extern "stdcall" fn(pUserData: *mut c_void,
                                                                         size: size_t,
                                                                         allocationType: VkInternalAllocationType,
                                                                         allocationScope: VkSystemAllocationScope);

pub type vkInternalFreeNotificationFn = unsafe extern "stdcall" fn(pUserData: *mut c_void,
                                                                   size: size_t,
                                                                   allocationType: VkInternalAllocationType,
                                                                   allocationScope: VkSystemAllocationScope);

pub type vkVoidFunctionFn = *const u8;

#[repr(C)]
pub struct VkApplicationInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pApplicationName: *const c_char,
    pub applicationVersion: u32,
    pub pEngineName: *const c_char,
    pub engineVersion: u32,
    pub apiVersion: u32
}

#[repr(C)]
pub struct VkInstanceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkInstanceCreateFlags,
    pub pApplicationInfo: *const VkApplicationInfo,
    pub enabledLayerCount: u32,
    pub ppEnabledLayerNames: *const *const c_char,
    pub enabledExtensionCount: u32,
    pub ppEnabledExtensionNames: *const *const c_char
}

#[repr(C)]
pub struct VkAllocationCallbacks {
    pub pUserData: *const c_void,
    pub pfnAllocation: vkAllocationFunctionFn,
    pub pfnReallocation: vkReallocationFunctionFn,
    pub pfnFree: vkFreeFunctionFn,
    pub pfnInternalAllocation: vkInternalAllocationNotificationFn,
    pub pfnInternalFree: vkInternalFreeNotificationFn
}

#[repr(C)]
pub struct VkPhysicalDeviceFeatures {
    pub robustBufferAccess: VkBool32,
    pub fullDrawIndexUint32: VkBool32,
    pub imageCubeArray: VkBool32,
    pub independentBlend: VkBool32,
    pub geometryShader: VkBool32,
    pub tessellationShader: VkBool32,
    pub sampleRateShading: VkBool32,
    pub dualSrcBlend: VkBool32,
    pub logicOp: VkBool32,
    pub multiDrawIndirect: VkBool32,
    pub drawIndirectFirstInstance: VkBool32,
    pub depthClamp: VkBool32,
    pub depthBiasClamp: VkBool32,
    pub fillModeNonSolid: VkBool32,
    pub depthBounds: VkBool32,
    pub wideLines: VkBool32,
    pub largePoints: VkBool32,
    pub alphaToOne: VkBool32,
    pub multiViewport: VkBool32,
    pub samplerAnisotropy: VkBool32,
    pub textureCompressionETC2: VkBool32,
    pub textureCompressionASTC_LDR: VkBool32,
    pub textureCompressionBC: VkBool32,
    pub occlusionQueryPrecise: VkBool32,
    pub pipelineStatisticsQuery: VkBool32,
    pub vertexPipelineStoresAndAtomics: VkBool32,
    pub fragmentStoresAndAtomics: VkBool32,
    pub shaderTessellationAndGeometryPointSize: VkBool32,
    pub shaderImageGatherExtended: VkBool32,
    pub shaderStorageImageExtendedFormats: VkBool32,
    pub shaderStorageImageMultisample: VkBool32,
    pub shaderStorageImageReadWithoutFormat: VkBool32,
    pub shaderStorageImageWriteWithoutFormat: VkBool32,
    pub shaderUniformBufferArrayDynamicIndexing: VkBool32,
    pub shaderSampledImageArrayDynamicIndexing: VkBool32,
    pub shaderStorageBufferArrayDynamicIndexing: VkBool32,
    pub shaderStorageImageArrayDynamicIndexing: VkBool32,
    pub shaderClipDistance: VkBool32,
    pub shaderCullDistance: VkBool32,
    pub shaderFloat64: VkBool32,
    pub shaderInt64: VkBool32,
    pub shaderInt16: VkBool32,
    pub shaderResourceResidency: VkBool32,
    pub shaderResourceMinLod: VkBool32,
    pub sparseBinding: VkBool32,
    pub sparseResidencyBuffer: VkBool32,
    pub sparseResidencyImage2D: VkBool32,
    pub sparseResidencyImage3D: VkBool32,
    pub sparseResidency2Samples: VkBool32,
    pub sparseResidency4Samples: VkBool32,
    pub sparseResidency8Samples: VkBool32,
    pub sparseResidency16Samples: VkBool32,
    pub sparseResidencyAliased: VkBool32,
    pub variableMultisampleRate: VkBool32,
    pub inheritedQueries: VkBool32
}

#[repr(C)]
pub struct VkFormatProperties {
    pub linearTilingFeatures: VkFormatFeatureFlags,
    pub optimalTilingFeatures: VkFormatFeatureFlags,
    pub bufferFeatures: VkFormatFeatureFlags
}

#[repr(C)]
pub struct VkExtent3D {
    pub width: uint32_t,
    pub height: uint32_t,
    pub depth: uint32_t
}

#[repr(C)]
pub struct VkImageFormatProperties {
    pub maxExtent: VkExtent3D,
    pub maxMipLevels: uint32_t,
    pub maxArrayLayers: uint32_t,
    pub sampleCounts: VkSampleCountFlags,
    pub maxResourceSize: VkDeviceSize
}

#[repr(C)]
pub struct VkPhysicalDeviceLimits {
    pub maxImageDimension2D: uint32_t,
    pub maxImageDimension1D: uint32_t,
    pub maxImageDimension3D: uint32_t,
    pub maxImageDimensionCube: uint32_t,
    pub maxImageArrayLayers: uint32_t,
    pub maxTexelBufferElements: uint32_t,
    pub maxUniformBufferRange: uint32_t,
    pub maxStorageBufferRange: uint32_t,
    pub maxPushConstantsSize: uint32_t,
    pub maxMemoryAllocationCount: uint32_t,
    pub maxSamplerAllocationCount: uint32_t,
    pub bufferImageGranularity: VkDeviceSize,
    pub sparseAddressSpaceSize: VkDeviceSize,
    pub maxBoundDescriptorSets: uint32_t,
    pub maxPerStageDescriptorSamplers: uint32_t,
    pub maxPerStageDescriptorUniformBuffers: uint32_t,
    pub maxPerStageDescriptorStorageBuffers: uint32_t,
    pub maxPerStageDescriptorSampledImages: uint32_t,
    pub maxPerStageDescriptorStorageImages: uint32_t,
    pub maxPerStageDescriptorInputAttachments: uint32_t,
    pub maxPerStageResources: uint32_t,
    pub maxDescriptorSetSamplers: uint32_t,
    pub maxDescriptorSetUniformBuffers: uint32_t,
    pub maxDescriptorSetUniformBuffersDynamic: uint32_t,
    pub maxDescriptorSetStorageBuffers: uint32_t,
    pub maxDescriptorSetStorageBuffersDynamic: uint32_t,
    pub maxDescriptorSetSampledImages: uint32_t,
    pub maxDescriptorSetStorageImages: uint32_t,
    pub maxDescriptorSetInputAttachments: uint32_t,
    pub maxVertexInputAttributes: uint32_t,
    pub maxVertexInputBindings: uint32_t,
    pub maxVertexInputAttributeOffset: uint32_t,
    pub maxVertexInputBindingStride: uint32_t,
    pub maxVertexOutputComponents: uint32_t,
    pub maxTessellationGenerationLevel: uint32_t,
    pub maxTessellationPatchSize: uint32_t,
    pub maxTessellationControlPerVertexInputComponents: uint32_t,
    pub maxTessellationControlPerVertexOutputComponents: uint32_t,
    pub maxTessellationControlPerPatchOutputComponents: uint32_t,
    pub maxTessellationControlTotalOutputComponents: uint32_t,
    pub maxTessellationEvaluationInputComponents: uint32_t,
    pub maxTessellationEvaluationOutputComponents: uint32_t,
    pub maxGeometryShaderInvocations: uint32_t,
    pub maxGeometryInputComponents: uint32_t,
    pub maxGeometryOutputComponents: uint32_t,
    pub maxGeometryOutputVertices: uint32_t,
    pub maxGeometryTotalOutputComponents: uint32_t,
    pub maxFragmentInputComponents: uint32_t,
    pub maxFragmentOutputAttachments: uint32_t,
    pub maxFragmentDualSrcAttachments: uint32_t,
    pub maxFragmentCombinedOutputResources: uint32_t,
    pub maxComputeSharedMemorySize: uint32_t,
    pub maxComputeWorkGroupCount: [uint32_t;3],
    pub maxComputeWorkGroupInvocations: uint32_t,
    pub maxComputeWorkGroupSize: [uint32_t;3],
    pub subPixelPrecisionBits: uint32_t,
    pub subTexelPrecisionBits: uint32_t,
    pub mipmapPrecisionBits: uint32_t,
    pub maxDrawIndexedIndexValue: uint32_t,
    pub maxDrawIndirectCount: uint32_t,
    pub maxSamplerLodBias: c_float,
    pub maxSamplerAnisotropy: c_float,
    pub maxViewports: uint32_t,
    pub maxViewportDimensions: [uint32_t;2],
    pub viewportBoundsRange: [c_float;2],
    pub viewportSubPixelBits: uint32_t,
    pub minMemoryMapAlignment: size_t,
    pub minTexelBufferOffsetAlignment: VkDeviceSize,
    pub minUniformBufferOffsetAlignment: VkDeviceSize,
    pub minStorageBufferOffsetAlignment: VkDeviceSize,
    pub minTexelOffset: int32_t,
    pub maxTexelOffset: uint32_t,
    pub minTexelGatherOffset: int32_t,
    pub maxTexelGatherOffset: uint32_t,
    pub minInterpolationOffset: c_float,
    pub maxInterpolationOffset: c_float,
    pub subPixelInterpolationOffsetBits: uint32_t,
    pub maxFramebufferWidth: uint32_t,
    pub maxFramebufferHeight: uint32_t,
    pub maxFramebufferLayers: uint32_t,
    pub framebufferColorSampleCounts: VkSampleCountFlags,
    pub framebufferDepthSampleCounts: VkSampleCountFlags,
    pub framebufferStencilSampleCounts: VkSampleCountFlags,
    pub framebufferNoAttachmentsSampleCounts: VkSampleCountFlags,
    pub maxColorAttachments: uint32_t,
    pub sampledImageColorSampleCounts: VkSampleCountFlags,
    pub sampledImageIntegerSampleCounts: VkSampleCountFlags,
    pub sampledImageDepthSampleCounts: VkSampleCountFlags,
    pub sampledImageStencilSampleCounts: VkSampleCountFlags,
    pub storageImageSampleCounts: VkSampleCountFlags,
    pub maxSampleMaskWords: uint32_t,
    pub timestampComputeAndGraphics: VkBool32,
    pub timestampPeriod: c_float,
    pub maxClipDistances: uint32_t,
    pub maxCullDistances: uint32_t,
    pub maxCombinedClipAndCullDistances: uint32_t,
    pub discreteQueuePriorities: uint32_t,
    pub pointSizeRange: [c_float;2],
    pub lineWidthRange: [c_float;2],
    pub pointSizeGranularity: c_float,
    pub lineWidthGranularity: c_float,
    pub strictLines: VkBool32,
    pub standardSampleLocations: VkBool32,
    pub optimalBufferCopyOffsetAlignment: VkDeviceSize,
    pub optimalBufferCopyRowPitchAlignment: VkDeviceSize,
    pub nonCoherentAtomSize: VkDeviceSize
}

#[repr(C)]
pub struct VkPhysicalDeviceSparseProperties {
    pub residencyStandard2DBlockShape: VkBool32,
    pub residencyStandard2DMultisampleBlockShape: VkBool32,
    pub residencyStandard3DBlockShape: VkBool32,
    pub residencyAlignedMipSize: VkBool32,
    pub residencyNonResidentStrict: VkBool32
}

#[repr(C)]
pub struct VkPhysicalDeviceProperties {
    pub apiVersion: uint32_t,
    pub driverVersion: uint32_t,
    pub vendorID: uint32_t,
    pub deviceID: uint32_t,
    pub deviceType: VkPhysicalDeviceType,
    pub deviceName: [c_char;VK_MAX_PHYSICAL_DEVICE_NAME_SIZE],
    pub pipelineCacheUUID: [uint8_t;VK_UUID_SIZE],
    pub limits: VkPhysicalDeviceLimits,
    pub sparseProperties: VkPhysicalDeviceSparseProperties,
}

#[repr(C)]
pub struct VkQueueFamilyProperties {
    pub queueFlags: VkQueueFlags,
    pub queueCount: uint32_t,
    pub timestampValidBits: uint32_t,
    pub minImageTransferGranularity: VkExtent3D
}

#[repr(C)]
pub struct VkMemoryType {
    pub propertyFlags: VkMemoryPropertyFlags,
    pub heapIndex: uint32_t
}

#[repr(C)]
pub struct VkMemoryHeap {
    pub size: VkDeviceSize,
    pub flags: VkMemoryHeapFlags
}

#[repr(C)]
pub struct VkPhysicalDeviceMemoryProperties {
    pub memoryTypeCount: uint32_t,
    pub memoryTypes: [VkMemoryType;VK_MAX_MEMORY_TYPES],
    pub memoryHeapCount: uint32_t,
    pub memoryHeaps: [VkMemoryHeap;VK_MAX_MEMORY_HEAPS]
}

#[repr(C)]
pub struct VkDeviceQueueCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDeviceQueueCreateFlags,
    pub queueFamilyIndex: uint32_t,
    pub queueCount: uint32_t,
    pub pQueuePriorities: *const c_float
}

#[repr(C)]
pub struct VkDeviceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDeviceCreateFlags,
    pub queueCreateInfoCount: uint32_t,
    pub pQueueCreateInfos: *const VkDeviceQueueCreateInfo,
    pub enabledLayerCount: uint32_t,
    pub ppEnabledLayerNames: *const *const c_char,
    pub enabledExtensionCount: uint32_t,
    pub ppEnabledExtensionNames: *const *const c_char,
    pub pEnabledFeatures: *const VkPhysicalDeviceFeatures
}

#[repr(C)]
pub struct VkExtensionProperties {
    pub extensionName: [c_char; VK_MAX_EXTENSION_NAME_SIZE],
    pub specVersion: uint32_t
}

#[repr(C)]
pub struct VkLayerProperties {
    pub layerName: [c_char;VK_MAX_EXTENSION_NAME_SIZE],
    pub specVersion: uint32_t,
    pub implementationVersion: uint32_t,
    pub description: [c_char;VK_MAX_DESCRIPTION_SIZE]
}

#[repr(C)]
pub struct VkSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub waitSemaphoreCount: uint32_t,
    pub pWaitSemaphores: *const VkSemaphore,
    pub pWaitDstStageMask: *const VkPipelineStageFlags,
    pub commandBufferCount: uint32_t,
    pub pCommandBuffers: *const VkCommandBuffer,
    pub signalSemaphoreCount: uint32_t,
    pub pSignalSemaphores: *const VkSemaphore
}

#[repr(C)]
pub struct VkMemoryAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub allocationSize: VkDeviceSize,
    pub memoryTypeIndex: uint32_t,
}

#[repr(C)]
pub struct VkMappedMemoryRange {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub memory: VkDeviceMemory,
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize
}

#[repr(C)]
pub struct VkMemoryRequirements {
    pub size: VkDeviceSize,
    pub alignment: VkDeviceSize,
    pub memoryTypeBits: uint32_t
}

#[repr(C)]
pub struct VkSparseImageFormatProperties {
    pub aspectMask: VkImageAspectFlags,
    pub imageGranularity: VkExtent3D,
    pub flags: VkSparseImageFormatFlags
}

#[repr(C)]
pub struct VkSparseImageMemoryRequirements {
    pub formatProperties: VkSparseImageFormatProperties,
    pub imageMipTailFirstLod: uint32_t,
    pub imageMipTailSize: VkDeviceSize,
    pub imageMipTailOffset: VkDeviceSize,
    pub imageMipTailStride: VkDeviceSize
}

#[repr(C)]
pub struct VkSparseMemoryBind {
    pub resourceOffset: VkDeviceSize,
    pub size: VkDeviceSize,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
    pub flags: VkSparseMemoryBindFlags
}

#[repr(C)]
pub struct VkSparseBufferMemoryBindInfo {
    pub buffer: VkBuffer,
    pub bindCount: uint32_t,
    pub pBinds: *const VkSparseMemoryBind
}

#[repr(C)]
pub struct VkSparseImageOpaqueMemoryBindInfo {
    pub image: VkImage,
    pub bindCount: uint32_t,
    pub pBinds: *const VkSparseMemoryBind
}

#[repr(C)]
pub struct VkImageSubresource {
    pub aspectMask: VkImageAspectFlags,
    pub mipLevel: uint32_t,
    pub arrayLayer: uint32_t
}

#[repr(C)]
pub struct VkOffset3D {
    pub x: int32_t,
    pub y: int32_t,
    pub z: int32_t
}

#[repr(C)]
pub struct VkSparseImageMemoryBind {
    pub subresource: VkImageSubresource,
    pub offset: VkOffset3D,
    pub extent: VkExtent3D,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
    pub flags: VkSparseMemoryBindFlags
}

#[repr(C)]
pub struct VkSparseImageMemoryBindInfo {
    pub image: VkImage,
    pub bindCount: uint32_t,
    pub pBinds: *const VkSparseImageMemoryBind
}

#[repr(C)]
pub struct VkBindSparseInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub waitSemaphoreCount: uint32_t,
    pub pWaitSemaphores: *const VkSemaphore,
    pub bufferBindCount: uint32_t,
    pub pBufferBinds: *const VkSparseBufferMemoryBindInfo,
    pub imageOpaqueBindCount: uint32_t,
    pub pImageOpaqueBinds: *const VkSparseImageOpaqueMemoryBindInfo,
    pub imageBindCount: uint32_t,
    pub pImageBinds: *const VkSparseImageMemoryBindInfo,
    pub signalSemaphoreCount: uint32_t,
    pub pSignalSemaphores: *const VkSemaphore
}

#[repr(C)]
pub struct VkFenceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkFenceCreateFlags
}

#[repr(C)]
pub struct VkSemaphoreCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkSemaphoreCreateFlags
}

#[repr(C)]
pub struct VkEventCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkEventCreateFlags
}

#[repr(C)]
pub struct VkQueryPoolCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkQueryPoolCreateFlags,
    pub queryType: VkQueryType,
    pub queryCount: uint32_t,
    pub pipelineStatistics: VkQueryPipelineStatisticFlags,
}

#[repr(C)]
pub struct VkBufferCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkBufferCreateFlags,
    pub size: VkDeviceSize,
    pub usage: VkBufferUsageFlags,
    pub sharingMode: VkSharingMode,
    pub queueFamilyIndexCount: uint32_t,
    pub pQueueFamilyIndices: *const uint32_t
}

#[repr(C)]
pub struct VkBufferViewCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkBufferViewCreateFlags,
    pub buffer: VkBuffer,
    pub format: VkFormat,
    pub offset: VkDeviceSize,
    pub range: VkDeviceSize
}

#[repr(C)]
pub struct VkImageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkImageCreateFlags,
    pub imageType: VkImageType,
    pub format: VkFormat,
    pub extent: VkExtent3D,
    pub mipLevels: uint32_t,
    pub arrayLayers: uint32_t,
    pub samples: VkSampleCountFlagBits,
    pub tiling: VkImageTiling,
    pub usage: VkImageUsageFlags,
    pub sharingMode: VkSharingMode,
    pub queueFamilyIndexCount: uint32_t,
    pub pQueueFamilyIndices: *const uint32_t,
    pub initialLayout: VkImageLayout
}

#[repr(C)]
pub struct VkSubresourceLayout {
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
    pub rowPitch: VkDeviceSize,
    pub arrayPitch: VkDeviceSize,
    pub depthPitch: VkDeviceSize
}

#[repr(C)]
pub struct VkComponentMapping {
    pub r: VkComponentSwizzle,
    pub g: VkComponentSwizzle,
    pub b: VkComponentSwizzle,
    pub a: VkComponentSwizzle
}

#[repr(C)]
pub struct VkImageSubresourceRange {
    pub aspectMask: VkImageAspectFlags,
    pub baseMipLevel: uint32_t,
    pub levelCount: uint32_t,
    pub baseArrayLayer: uint32_t,
    pub layerCount: uint32_t
}

#[repr(C)]
pub struct VkImageViewCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkImageViewCreateFlags,
    pub image: VkImage,
    pub viewType: VkImageViewType,
    pub format: VkFormat,
    pub components: VkComponentMapping,
    pub subresourceRange: VkImageSubresourceRange
}

#[repr(C)]
pub struct VkShaderModuleCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkShaderModuleCreateFlags,
    pub codeSize: size_t,
    pub pCode: *const uint32_t
}

#[repr(C)]
pub struct VkPipelineCacheCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCacheCreateFlags,
    pub initialDataSize: size_t,
    pub pInitialData: *const c_void
}

#[repr(C)]
pub struct VkSpecializationMapEntry {
    pub constantID: uint32_t,
    pub offset: uint32_t,
    pub size: size_t
}

#[repr(C)]
pub struct VkSpecializationInfo {
    pub mapEntryCount: uint32_t,
    pub pMapEntries: *const VkSpecializationMapEntry,
    pub dataSize: size_t,
    pub pData: *const c_void
}

#[repr(C)]
pub struct VkPipelineShaderStageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineShaderStageCreateFlags,
    pub stage: VkShaderStageFlagBits,
    pub module: VkShaderModule,
    pub pName: *const c_char,
    pub pSpecializationInfo: *const VkSpecializationInfo
}

#[repr(C)]
pub struct VkVertexInputBindingDescription {
    pub binding: uint32_t,
    pub stride: uint32_t,
    pub inputRate: VkVertexInputRate
}

#[repr(C)]
pub struct VkVertexInputAttributeDescription {
    pub location: uint32_t,
    pub binding: uint32_t,
    pub format: VkFormat,
    pub offset: uint32_t
}

#[repr(C)]
pub struct VkPipelineVertexInputStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineVertexInputStateCreateFlags,
    pub vertexBindingDescriptionCount: uint32_t,
    pub pVertexBindingDescriptions: *const VkVertexInputBindingDescription,
    pub vertexAttributeDescriptionCount: uint32_t,
    pub pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription
}

#[repr(C)]
pub struct VkPipelineInputAssemblyStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineInputAssemblyStateCreateFlags,
    pub topology: VkPrimitiveTopology,
    pub primitiveRestartEnable: VkBool32
}

#[repr(C)]
pub struct VkPipelineTessellationStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineTessellationStateCreateFlags,
    pub patchControlPoints: uint32_t
}

#[repr(C)]
pub struct VkViewport {
    pub x: c_float,
    pub y: c_float,
    pub width: c_float,
    pub height: c_float,
    pub minDepth: c_float,
    pub maxDepth: c_float
}

#[repr(C)]
pub struct VkOffset2D {
    pub x: int32_t,
    pub y: int32_t
}

#[repr(C)]
pub struct VkExtent2D {
    pub width: uint32_t,
    pub height: uint32_t
}

#[repr(C)]
pub struct VkRect2D {
    pub offset: VkOffset2D,
    pub extent: VkExtent2D
}

#[repr(C)]
pub struct VkPipelineViewportStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineViewportStateCreateFlags,
    pub viewportCount: uint32_t,
    pub pViewports: *const VkViewport,
    pub scissorCount: uint32_t,
    pub pScissors: *const VkRect2D
}

#[repr(C)]
pub struct VkPipelineRasterizationStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineRasterizationStateCreateFlags,
    pub depthClampEnable: VkBool32,
    pub rasterizerDiscardEnable: VkBool32,
    pub polygonMode: VkPolygonMode,
    pub cullMode: VkCullModeFlags,
    pub frontFace: VkFrontFace,
    pub depthBiasEnable: VkBool32,
    pub depthBiasConstantFactor: c_float,
    pub depthBiasClamp: c_float,
    pub depthBiasSlopeFactor: c_float,
    pub lineWidth: c_float
}

#[repr(C)]
pub struct VkPipelineMultisampleStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineMultisampleStateCreateFlags,
    pub rasterizationSamples: VkSampleCountFlagBits,
    pub sampleShadingEnable: VkBool32,
    pub minSampleShading: c_float,
    pub pSampleMask: *const VkSampleMask,
    pub alphaToCoverageEnable: VkBool32,
    pub alphaToOneEnable: VkBool32
}

#[repr(C)]
pub struct VkStencilOpState {
    pub failOp: VkStencilOp,
    pub passOp: VkStencilOp,
    pub depthFailOp: VkStencilOp,
    pub compareOp: VkCompareOp,
    pub compareMask: uint32_t,
    pub writeMask: uint32_t,
    pub reference: uint32_t
}

#[repr(C)]
pub struct VkPipelineDepthStencilStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineDepthStencilStateCreateFlags,
    pub depthTestEnable: VkBool32,
    pub depthWriteEnable: VkBool32,
    pub depthCompareOp: VkCompareOp,
    pub depthBoundsTestEnable: VkBool32,
    pub stencilTestEnable: VkBool32,
    pub front: VkStencilOpState,
    pub back: VkStencilOpState,
    pub minDepthBounds: c_float,
    pub maxDepthBounds: c_float
}

#[repr(C)]
pub struct VkPipelineColorBlendAttachmentState {
    pub blendEnable: VkBool32,
    pub srcColorBlendFactor: VkBlendFactor,
    pub dstColorBlendFactor: VkBlendFactor,
    pub colorBlendOp: VkBlendOp,
    pub srcAlphaBlendFactor: VkBlendFactor,
    pub dstAlphaBlendFactor: VkBlendFactor,
    pub alphaBlendOp: VkBlendOp,
    pub colorWriteMask: VkColorComponentFlags
}

#[repr(C)]
pub struct VkPipelineColorBlendStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineColorBlendStateCreateFlags,
    pub logicOpEnable: VkBool32,
    pub logicOp: VkLogicOp,
    pub attachmentCount: uint32_t,
    pub pAttachments: *const VkPipelineColorBlendAttachmentState,
    pub blendConstants: [c_float;4]
}

#[repr(C)]
pub struct VkPipelineDynamicStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineDynamicStateCreateFlags,
    pub dynamicStateCount: uint32_t,
    pub pDynamicStates: *const VkDynamicState
}

#[repr(C)]
pub struct VkGraphicsPipelineCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCreateFlags,
    pub stageCount: uint32_t,
    pub pStages: *const VkPipelineShaderStageCreateInfo,
    pub pVertexInputState: *const VkPipelineVertexInputStateCreateInfo,
    pub pInputAssemblyState: *const VkPipelineInputAssemblyStateCreateInfo,
    pub pTessellationState: *const VkPipelineTessellationStateCreateInfo,
    pub pViewportState: *const VkPipelineViewportStateCreateInfo,
    pub pRasterizationState: *const VkPipelineRasterizationStateCreateInfo,
    pub pMultisampleState: *const VkPipelineMultisampleStateCreateInfo,
    pub pDepthStencilState: *const VkPipelineDepthStencilStateCreateInfo,
    pub pColorBlendState: *const VkPipelineColorBlendStateCreateInfo,
    pub pDynamicState: *const VkPipelineDynamicStateCreateInfo,
    pub layout: VkPipelineLayout,
    pub renderPass: VkRenderPass,
    pub subpass: uint32_t,
    pub basePipelineHandle: VkPipeline,
    pub basePipelineIndex: int32_t
}

#[repr(C)]
pub struct VkComputePipelineCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCreateFlags,
    pub stage: VkPipelineShaderStageCreateInfo,
    pub layout: VkPipelineLayout,
    pub basePipelineHandle: VkPipeline,
    pub basePipelineIndex: int32_t
}

#[repr(C)]
pub struct VkPushConstantRange {
    pub stageFlags: VkShaderStageFlags,
    pub offset: uint32_t,
    pub size: uint32_t
}

#[repr(C)]
pub struct VkPipelineLayoutCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineLayoutCreateFlags,
    pub setLayoutCount: uint32_t,
    pub pSetLayouts: *const VkDescriptorSetLayout,
    pub pushConstantRangeCount: uint32_t,
    pub pPushConstantRanges: *const VkPushConstantRange
}

#[repr(C)]
pub struct VkSamplerCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkSamplerCreateFlags,
    pub magFilter: VkFilter,
    pub minFilter: VkFilter,
    pub mipmapMode: VkSamplerMipmapMode,
    pub addressModeU: VkSamplerAddressMode,
    pub addressModeV: VkSamplerAddressMode,
    pub addressModeW: VkSamplerAddressMode,
    pub mipLodBias: c_float,
    pub anisotropyEnable: VkBool32,
    pub maxAnisotropy: c_float,
    pub compareEnable: VkBool32,
    pub compareOp: VkCompareOp,
    pub minLod: c_float,
    pub maxLod: c_float,
    pub borderColor: VkBorderColor,
    pub unnormalizedCoordinates: VkBool32
}

#[repr(C)]
pub struct VkDescriptorSetLayoutBinding {
    pub binding: uint32_t,
    pub descriptorType: VkDescriptorType,
    pub descriptorCount: uint32_t,
    pub stageFlags: VkShaderStageFlags,
    pub pImmutableSamplers: *const VkSampler
}

#[repr(C)]
pub struct VkDescriptorSetLayoutCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDescriptorSetLayoutCreateFlags,
    pub bindingCount: uint32_t,
    pub pBindings: *const VkDescriptorSetLayoutBinding
}


// TODO
#[repr(C)]
pub struct VkDescriptorPoolSize {
    /// Renamed from type to dType due to keyword collision
    pub dType: VkDescriptorType,
    pub descriptorCount: uint32_t,
}

#[repr(C)]
pub struct VkDescriptorPoolCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDescriptorPoolCreateFlags,
    pub maxSets: uint32_t,
    pub poolSizeCount: uint32_t,
    pub pPoolSizes: *const VkDescriptorPoolSize
}

#[repr(C)]
pub struct VkDescriptorSetAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub descriptorPool: VkDescriptorPool,
    pub descriptorSetCount: uint32_t,
    pub pSetLayouts: *const VkDescriptorSetLayout
}

#[repr(C)]
pub struct VkDescriptorImageInfo {
    pub sampler: VkSampler,
    pub imageView: VkImageView,
    pub imageLayout: VkImageLayout
}

#[repr(C)]
pub struct VkDescriptorBufferInfo {
    pub buffer: VkBuffer,
    pub offset: VkDeviceSize,
    pub range: VkDeviceSize
}

#[repr(C)]
pub struct VkWriteDescriptorSet {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dstSet: VkDescriptorSet,
    pub dstBinding: uint32_t,
    pub dstArrayElement: uint32_t,
    pub descriptorCount: uint32_t,
    pub descriptorType: VkDescriptorType,
    pub pImageInfo: *const VkDescriptorImageInfo,
    pub pBufferInfo: *const VkDescriptorBufferInfo,
    pub pTexelBufferView: *const VkBufferView
}

#[repr(C)]
pub struct VkCopyDescriptorSet {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcSet: VkDescriptorSet,
    pub srcBinding: uint32_t,
    pub srcArrayElement: uint32_t,
    pub dstSet: VkDescriptorSet,
    pub dstBinding: uint32_t,
    pub dstArrayElement: uint32_t,
    pub descriptorCount: uint32_t
}

#[repr(C)]
pub struct VkFramebufferCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkFramebufferCreateFlags,
    pub renderPass: VkRenderPass,
    pub attachmentCount: uint32_t,
    pub pAttachments: *const VkImageView,
    pub width: uint32_t,
    pub height: uint32_t,
    pub layers: uint32_t
}

#[repr(C)]
pub struct VkAttachmentDescription {
    pub flags: VkAttachmentDescriptionFlags,
    pub format: VkFormat,
    pub samples: VkSampleCountFlagBits,
    pub loadOp: VkAttachmentLoadOp,
    pub storeOp: VkAttachmentStoreOp,
    pub stencilLoadOp: VkAttachmentLoadOp,
    pub stencilStoreOp: VkAttachmentStoreOp,
    pub initialLayout: VkImageLayout,
    pub finalLayout: VkImageLayout
}

#[repr(C)]
pub struct VkAttachmentReference {
    pub attachment: uint32_t,
    pub layout: VkImageLayout
}

#[repr(C)]
pub struct VkSubpassDescription {
    pub flags: VkSubpassDescriptionFlags,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub inputAttachmentCount: uint32_t,
    pub pInputAttachments: *const VkAttachmentReference,
    pub colorAttachmentCount: uint32_t,
    pub pColorAttachments: *const VkAttachmentReference,
    pub pResolveAttachments: *const VkAttachmentReference,
    pub pDepthStencilAttachment: *const VkAttachmentReference,
    pub preserveAttachmentCount: uint32_t,
    pub pPreserveAttachments: *const uint32_t
}

#[repr(C)]
pub struct VkSubpassDependency {
    pub srcSubpass: uint32_t,
    pub dstSubpass: uint32_t,
    pub srcStageMask: VkPipelineStageFlags,
    pub dstStageMask: VkPipelineStageFlags,
    pub srcAccessMask: VkAccessFlags,
    pub dstAccessMask: VkAccessFlags,
    pub dependencyFlags: VkDependencyFlags
}

#[repr(C)]
pub struct VkRenderPassCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkRenderPassCreateFlags,
    pub attachmentCount: uint32_t,
    pub pAttachments: *const VkAttachmentDescription,
    pub subpassCount: uint32_t,
    pub pSubpasses: *const VkSubpassDescription,
    pub dependencyCount: uint32_t,
    pub pDependencies: *const VkSubpassDependency
}

#[repr(C)]
pub struct VkCommandPoolCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkCommandPoolCreateFlags,
    pub queueFamilyIndex: uint32_t
}

#[repr(C)]
pub struct VkCommandBufferAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub commandPool: VkCommandPool,
    pub level: VkCommandBufferLevel,
    pub commandBufferCount: uint32_t
}

#[repr(C)]
pub struct VkCommandBufferInheritanceInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub renderPass: VkRenderPass,
    pub subpass: uint32_t,
    pub framebuffer: VkFramebuffer,
    pub occlusionQueryEnable: VkBool32,
    pub queryFlags: VkQueryControlFlags,
    pub pipelineStatistics: VkQueryPipelineStatisticFlags
}

#[repr(C)]
pub struct VkCommandBufferBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkCommandBufferUsageFlags,
    pub pInheritanceInfo: *const VkCommandBufferInheritanceInfo
}

#[repr(C)]
pub struct VkBufferCopy {
    pub srcOffset: VkDeviceSize,
    pub dstOffset: VkDeviceSize,
    pub size: VkDeviceSize
}

#[repr(C)]
pub struct VkImageSubresourceLayers {
    pub aspectMask: VkImageAspectFlags,
    pub mipLevel: uint32_t,
    pub baseArrayLayer: uint32_t,
    pub layerCount: uint32_t
}

#[repr(C)]
pub struct VkImageCopy {
    pub srcSubresource: VkImageSubresourceLayers,
    pub srcOffset: VkOffset3D,
    pub dstSubresource: VkImageSubresourceLayers,
    pub dstOffset: VkOffset3D,
    pub extent: VkExtent3D
}

#[repr(C)]
pub struct VkImageBlit {
    pub srcSubresource: VkImageSubresourceLayers,
    pub srcOffsets: [VkOffset3D;2],
    pub dstSubresource: VkImageSubresourceLayers,
    pub dstOffsets: [VkOffset3D;2]
}

#[repr(C)]
pub struct VkBufferImageCopy {
    pub bufferOffset: VkDeviceSize,
    pub bufferRowLength: uint32_t,
    pub bufferImageHeight: uint32_t,
    pub imageSubresource: VkImageSubresourceLayers,
    pub imageOffset: VkOffset3D,
    pub imageExtent: VkExtent3D
}

#[repr(C)]
pub struct VkClearColorValue {
    pub union_data: [u8;16]
}

#[repr(C)]
pub enum VkClearColorValueUnion {
    Float32([c_float;4]),
    Int32([int32_t;4]),
    UInt32([uint32_t;4])
}

impl From<VkClearColorValueUnion> for VkClearColorValue {
    fn from(union:VkClearColorValueUnion) -> Self {
        unsafe {
            match union {
                VkClearColorValueUnion::Float32(color4f) => {
                    VkClearColorValue{union_data:std::mem::transmute(color4f)}
                },
                VkClearColorValueUnion::Int32(color4i) => {
                    VkClearColorValue{union_data:std::mem::transmute(color4i)}
                },
                VkClearColorValueUnion::UInt32(color4u) => {
                    VkClearColorValue{union_data:std::mem::transmute(color4u)}
                },
            }
        }
    }
}

#[repr(C)]
pub struct VkClearDepthStencilValue {
    depth: c_float,
    stencil: uint32_t
}

#[repr(C)]
pub struct VkClearValue {
    union_data: [u8;16]
}

pub enum VkClearValueUnion {
    Color(VkClearColorValue),
    DepthStencil(VkClearDepthStencilValue)
}

impl From<VkClearValueUnion> for VkClearValue {
    fn from(union: VkClearValueUnion) -> Self {
        unsafe {
            match union {
                VkClearValueUnion::Color(clear_color_value) => {
                    VkClearValue{union_data:clear_color_value.union_data}
                },
                VkClearValueUnion::DepthStencil(clear_depth_stencil_value) => {
                    let mut clear_value:VkClearValue = std::mem::zeroed();
                    {
                        let clear_color_bytes: [u8;8] = std::mem::transmute(clear_depth_stencil_value);
                        let union_data_slice: &mut[u8] = &mut clear_value.union_data[0..8];
                        union_data_slice.clone_from_slice(&clear_color_bytes);
                    }
                    clear_value
                }
            }
        }
    }
}

#[repr(C)]
pub struct VkClearAttachment {
    aspectMask: VkImageAspectFlags,
    colorAttachment: uint32_t,
    clearValue: VkClearValue
}

#[repr(C)]
pub struct VkClearRect {
    rect: VkRect2D,
    baseArrayLayer: uint32_t,
    layerCount: uint32_t
}

#[repr(C)]
pub struct VkImageResolve {
    srcSubresource: VkImageSubresourceLayers,
    srcOffset: VkOffset3D,
    dstSubresource: VkImageSubresourceLayers,
    dstOffset: VkOffset3D,
    extent: VkExtent3D
}

#[repr(C)]
pub struct VkMemoryBarrier {
    sType: VkStructureType,
    pNext: *const c_void,
    srcAccessMask: VkAccessFlags,
    dstAccessMask: VkAccessFlags
}

#[repr(C)]
pub struct VkBufferMemoryBarrier {
    sType: VkStructureType,
    pNext: *const c_void,
    srcAccessMask: VkAccessFlags,
    dstAccessMask: VkAccessFlags,
    srcQueueFamilyIndex: uint32_t,
    dstQueueFamilyIndex: uint32_t,
    buffer: VkBuffer,
    offset: VkDeviceSize,
    size: VkDeviceSize
}

#[repr(C)]
pub struct VkImageMemoryBarrier {
    sType: VkStructureType,
    pNext: *const c_void,
    srcAccessMask: VkAccessFlags,
    dstAccessMask: VkAccessFlags,
    oldLayout: VkImageLayout,
    newLayout: VkImageLayout,
    srcQueueFamilyIndex: uint32_t,
    dstQueueFamilyIndex: uint32_t,
    image: VkImage,
    subresourceRange: VkImageSubresourceRange
}

#[repr(C)]
pub struct VkRenderPassBeginInfo {
    sType: VkStructureType,
    pNext: *const c_void,
    renderPass: VkRenderPass,
    framebuffer: VkFramebuffer,
    renderArea: VkRect2D,
    clearValueCount: uint32_t,
    pClearValues: *const VkClearValue
}

#[repr(C)]
pub struct VkDispatchIndirectCommand {
    x: uint32_t,
    y: uint32_t,
    z: uint32_t
}

#[repr(C)]
pub struct VkDrawIndexedIndirectCommand {
    indexCount: uint32_t,
    instanceCount: uint32_t,
    firstIndex: uint32_t,
    vertexOffset: int32_t,
    firstInstance: uint32_t
}

#[repr(C)]
pub struct VkDrawIndirectCommand {
    vertexCount: uint32_t,
    instanceCount: uint32_t,
    firstVertex: uint32_t,
    firstInstance: uint32_t
}

pub type vkCreateInstanceFn = unsafe extern "stdcall" fn(pCreateInfo: *const VkInstanceCreateInfo, 
                                                         pAllocator: *const VkAllocationCallbacks, 
                                                         pInstance: *mut VkInstance) -> VkResult;

pub type vkDestroyInstanceFn = unsafe extern "stdcall" fn(instance: VkInstance, 
                                                          pAllocator: *const VkAllocationCallbacks);

pub type vkEnumeratePhysicalDevicesFn = unsafe extern "stdcall" fn(instance: VkInstance, 
                                                                   pPhysicalDeviceCount: *mut uint32_t, 
                                                                   pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult;

pub type vkGetPhysicalDeviceFeaturesFn = unsafe extern "stdcall" fn(physicalDevice: VkPhysicalDevice, 
                                                                    pFeatures: *mut VkPhysicalDeviceFeatures);

pub type vkGetPhysicalDeviceFormatPropertiesFn = unsafe extern "stdcall" fn(physicalDevice: VkPhysicalDevice, 
                                                                            format: VkFormat, 
                                                                            pFormatProperties: *mut VkFormatProperties);

pub type vkGetPhysicalDeviceImageFormatPropertiesFn = unsafe extern "stdcall" fn(physicalDevice: VkPhysicalDevice,
                                                                                 format: VkFormat,
                                                                                 iType: VkImageType,
                                                                                 tiling: VkImageTiling,
                                                                                 usage: VkImageUsageFlags,
                                                                                 flags: VkImageCreateFlags,
                                                                                 pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult;

pub type vkGetPhysicalDevicePropertiesFn = unsafe extern "stdcall" fn(physicalDevice: VkPhysicalDevice,
                                                                      pProperties: *mut VkPhysicalDeviceProperties);

pub type vkGetPhysicalDeviceQueueFamilyPropertiesFn = unsafe extern "stdcall" fn(physicalDevice: VkPhysicalDevice,
                                                                                 pQueueFamilyPropertyCount: *mut uint32_t,
                                                                                 pQueueFamilyProperties: *mut VkQueueFamilyProperties);

pub type vkGetPhysicalDeviceMemoryPropertiesFn = unsafe extern "stdcall" fn(physicalDevice: VkPhysicalDevice,
                                                                            pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties);

pub type vkGetInstanceProcAddrFn = unsafe extern "stdcall" fn(instance: VkInstance,
                                                              pName: *const c_char) -> vkVoidFunctionFn;

pub type vkGetDeviceProcAddrFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                            pName: *const c_char) -> vkVoidFunctionFn;

pub type vkCreateDeviceFn = unsafe extern "stdcall" fn(physicalDevice: VkPhysicalDevice,
                                                       pCreateInfo: *const VkDeviceCreateInfo,
                                                       pAllocator: *const VkAllocationCallbacks,
                                                       pDevice: *mut VkDevice) -> VkResult;

pub type vkDestroyDeviceFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                        pAllocator: *const VkAllocationCallbacks);

pub type vkEnumerateInstanceExtensionPropertiesFn = unsafe extern "stdcall" fn(pLayerName: *const c_char,
                                                                               pPropertyCount: *mut uint32_t,
                                                                               pProperties: *mut VkExtensionProperties) -> VkResult;

pub type vkEnumerateDeviceExtensionPropertiesFn = unsafe extern "stdcall" fn(physicalDevice: VkPhysicalDevice,
                                                                             pLayerName: *const c_char,
                                                                             pPropertyCount: *mut uint32_t,
                                                                             pProperties: *mut VkExtensionProperties) -> VkResult;

pub type vkEnumerateInstanceLayerPropertiesFn = unsafe extern "stdcall" fn(pPropertyCount: *mut uint32_t,
                                                                           pProperties: *mut VkLayerProperties) -> VkResult;

pub type vkEnumerateDeviceLayerPropertiesFn = unsafe extern "stdcall" fn(physicalDevice: VkPhysicalDevice,
                                                                         pPropertyCount: *mut uint32_t,
                                                                         pProperties: *mut VkLayerProperties) -> VkResult;

pub type vkGetDeviceQueueFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                         queueFamilyIndex: uint32_t,
                                                         queueIndex: uint32_t,
                                                         pQueue: *mut VkQueue);

pub type vkQueueSubmitFn = unsafe extern "stdcall" fn(queue: VkQueue,
                                                      submitCount: uint32_t,
                                                      pSubmits: *const VkSubmitInfo,
                                                      fence: VkFence) -> VkResult;

pub type vkQueueWaitIdleFn = unsafe extern "stdcall" fn(queue: VkQueue) -> VkResult;

pub type vkDeviceWaitIdleFn = unsafe extern "stdcall" fn(device: VkDevice) -> VkResult;

pub type vkAllocateMemoryFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                         pAllocateInfo: *const VkMemoryAllocateInfo,
                                                         pAllocator: *const VkAllocationCallbacks,
                                                         pMemory: *mut VkDeviceMemory) -> VkResult;

pub type vkFreeMemoryFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                     memory: VkDeviceMemory,
                                                     pAllocator: *const VkAllocationCallbacks);

pub type vkMapMemoryFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                    memory: VkDeviceMemory,
                                                    offset: VkDeviceSize,
                                                    size: VkDeviceSize,
                                                    flags: VkMemoryMapFlags,
                                                    ppData: *mut *mut c_void) -> VkResult;

pub type vkUnmapMemoryFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                      memory: VkDeviceMemory);

pub type vkFlushMappedMemoryRangesFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                  memoryRangeCount: uint32_t,
                                                                  pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;

pub type vkInvalidateMappedMemoryRangesFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                       memoryRangeCount: uint32_t,
                                                                       pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;

pub type vkGetDeviceMemoryCommitmentFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                    memory: VkDeviceMemory,
                                                                    pCommittedMemoryInBytes: *mut VkDeviceSize);

pub type vkBindBufferMemoryFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                           buffer: VkBuffer,
                                                           memory: VkDeviceMemory,
                                                           memoryOffset: VkDeviceSize) -> VkResult;

pub type vkBindImageMemoryFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                          image: VkImage,
                                                          memory: VkDeviceMemory,
                                                          memoryOffset: VkDeviceSize) -> VkResult;

pub type vkGetBufferMemoryRequirementsFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                      buffer: VkBuffer,
                                                                      pMemoryRequirements: *mut VkMemoryRequirements);

pub type vkGetImageMemoryRequirementsFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                     image: VkImage,
                                                                     pMemoryRequirements: *mut VkMemoryRequirements);

pub type vkGetImageSparseMemoryRequirementsFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                           image: VkImage,
                                                                           pSparseMemoryRequirementCount: *mut uint32_t,
                                                                           pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements);

pub type vkGetPhysicalDeviceSparseImageFormatPropertiesFn = unsafe extern "stdcall" fn(physicalDevice: VkPhysicalDevice,
                                                                                       format: VkFormat,
                                                                                       iType: VkImageType,
                                                                                       samples: VkSampleCountFlagBits,
                                                                                       usage: VkImageUsageFlags,
                                                                                       tiling: VkImageTiling,
                                                                                       pPropertyCount: *mut uint32_t,
                                                                                       pProperties: *mut VkSparseImageFormatProperties);
pub type vkQueueBindSparseFn = unsafe extern "stdcall" fn(queue: VkQueue,
                                                          bindInfoCount: uint32_t,
                                                          pBindInfo: *const VkBindSparseInfo,
                                                          fence: VkFence) -> VkResult;

pub type vkCreateFenceFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                      pCreateInfo: *const VkFenceCreateInfo,
                                                      pAllocator: *const VkAllocationCallbacks,
                                                      pFence: *mut VkFence) -> VkResult;

pub type vkDestroyFenceFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                       fence: VkFence,
                                                       pAllocator: *const VkAllocationCallbacks);

pub type vkResetFencesFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                      fenceCount: uint32_t,
                                                      pFences: *const VkFence) -> VkResult;

pub type vkGetFenceStatusFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                         fence: VkFence) -> VkResult;

pub type vkWaitForFencesFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                        fenceCount: uint32_t,
                                                        pFences: *const VkFence,
                                                        waitAll: VkBool32,
                                                        timeout: uint64_t) -> VkResult;

pub type vkCreateSemaphoreFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                          pCreateInfo: *const VkSemaphoreCreateInfo,
                                                          pAllocator: *const VkAllocationCallbacks,
                                                          pSemaphore: *mut VkSemaphore) -> VkResult;

pub type vkDestroySemaphoreFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                           semaphore: VkSemaphore,
                                                           pAllocator: *const VkAllocationCallbacks);

pub type vkCreateEventFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                      pCreateInfo: *const VkEventCreateInfo,
                                                      pAllocator: *const VkAllocationCallbacks,
                                                      pEvent: *mut VkEvent) -> VkResult;

pub type vkDestroyEventFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                       event: VkEvent,
                                                       pAllocator: *const VkAllocationCallbacks);

pub type vkGetEventStatusFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                         event: VkEvent) -> VkResult;

pub type vkSetEventFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                   event: VkEvent) -> VkResult;

pub type vkResetEventFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                     event: VkEvent) -> VkResult;

pub type vkCreateQueryPoolFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                          pCreateInfo: *const VkQueryPoolCreateInfo,
                                                          pAllocator: *const VkAllocationCallbacks,
                                                          pQueryPool: *mut VkQueryPool) -> VkResult;

pub type vkDestroyQueryPoolFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                           queryPool: VkQueryPool,
                                                           pAllocator: *const VkAllocationCallbacks);

pub type vkGetQueryPoolResultsFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                              queryPool: VkQueryPool,
                                                              firstQuery: uint32_t,
                                                              queryCount: uint32_t,
                                                              dataSize: size_t,
                                                              pData: *mut c_void,
                                                              stride: VkDeviceSize,
                                                              flags: VkDeviceSize) -> VkResult;

pub type vkCreateBufferFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                       pCreateInfo: *const VkBufferCreateInfo,
                                                       pAllocator: *const VkAllocationCallbacks,
                                                       pBuffer: *mut VkBuffer) -> VkResult;

pub type vkDestroyBufferFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                        buffer: VkBuffer,
                                                        pAllocator: *const VkAllocationCallbacks);

pub type vkCreateBufferViewFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                           pCreateInfo: *const VkBufferViewCreateInfo,
                                                           pAllocator: *const VkAllocationCallbacks,
                                                           pView: *mut VkBufferView) -> VkResult;

pub type vkDestroyBufferViewFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                            bufferView: VkBufferView,
                                                            pAllocator: *const VkAllocationCallbacks);

pub type vkCreateImageFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                      pCreateInfo: *const VkImageCreateInfo,
                                                      pAllocator: *const VkAllocationCallbacks,
                                                      pImage: *mut VkImage) -> VkResult;

pub type vkDestroyImageFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                       image: VkImage,
                                                       pAllocator: *const VkAllocationCallbacks);

pub type vkGetImageSubresourceLayoutFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                    image: VkImage,
                                                                    pSubresource: *const VkImageSubresource,
                                                                    pLayout: *mut VkSubresourceLayout);

pub type vkCreateImageViewFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                          pCreateInfo: *const VkImageViewCreateInfo,
                                                          pAllocator: *const VkAllocationCallbacks,
                                                          pView: *mut VkImageView) -> VkResult;

pub type vkDestroyImageViewFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                           imageView: VkImageView,
                                                           pAllocator: *const VkAllocationCallbacks);

pub type vkCreateShaderModuleFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                             pCreateInfo: *const VkShaderModuleCreateInfo,
                                                             pAllocator: *const VkAllocationCallbacks,
                                                             pShaderModule: *mut VkShaderModule) -> VkResult;

pub type vkDestroyShaderModuleFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                              shaderModule: VkShaderModule,
                                                              pAllocator: *const VkAllocationCallbacks);

pub type vkCreatePipelineCacheFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                              pCreateInfo: *const VkPipelineCacheCreateInfo,
                                                              pAllocator: *const VkAllocationCallbacks,
                                                              pPipelineCache: *mut VkPipelineCache) -> VkResult;

pub type vkDestroyPipelineCacheFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                               pipelineCache: VkPipelineCache,
                                                               pAllocator: *const VkAllocationCallbacks);

pub type vkGetPipelineCacheDataFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                               pipelineCache: VkPipelineCache,
                                                               pDataSize: *mut size_t,
                                                               pData: *mut c_void) -> VkResult;

pub type vkMergePipelineCachesFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                              dstCache: VkPipelineCache,
                                                              srcCacheCount: uint32_t,
                                                              pSrcCaches: *const VkPipelineCache) -> VkResult;

pub type vkCreateGraphicsPipelinesFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                  pipelineCache: VkPipelineCache,
                                                                  createInfoCount: uint32_t,
                                                                  pCreateInfos: *const VkGraphicsPipelineCreateInfo,
                                                                  pAllocator: *const VkAllocationCallbacks,
                                                                  pPipelines: *mut VkPipeline) -> VkResult;

pub type vkCreateComputePipelinesFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                 pipelineCache: VkPipelineCache,
                                                                 createInfoCount: uint32_t,
                                                                 pCreateInfos: *const VkComputePipelineCreateInfo,
                                                                 pAllocator: *const VkAllocationCallbacks,
                                                                 pPipelines: *mut VkPipeline) -> VkResult;

pub type vkDestroyPipelineFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                          pipeline: VkPipeline,
                                                          pAllocator: *const VkAllocationCallbacks);

pub type vkCreatePipelineLayoutFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                               pCreateInfo: *const VkPipelineLayoutCreateInfo,
                                                               pAllocator: *const VkAllocationCallbacks,
                                                               pPipelineLayout: *mut VkPipelineLayout) -> VkResult;

pub type vkDestroyPipelineLayoutFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                pipelineLayout: VkPipelineLayout,
                                                                pAllocator: *const VkAllocationCallbacks);

pub type vkCreateSamplerFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                        pCreateInfo: *const VkSamplerCreateInfo,
                                                        pAllocator: *const VkAllocationCallbacks,
                                                        pSampler: *mut VkSampler) -> VkResult;

pub type vkDestroySamplerFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                         sampler: VkSampler,
                                                         pAllocator: *const VkAllocationCallbacks);

pub type vkCreateDescriptorSetLayoutFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                    pCreateInfo: *const VkDescriptorSetLayoutCreateInfo,
                                                                    pAllocator: *const VkAllocationCallbacks,
                                                                    pSetLayout: *mut VkDescriptorSetLayout) -> VkResult;

pub type vkDestroyDescriptorSetLayoutFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                     descriptorSetLayout: VkDescriptorSetLayout,
                                                                     pAllocator: *const VkAllocationCallbacks);

pub type vkCreateDescriptorPoolFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                               pCreateInfo: *const VkDescriptorPoolCreateInfo,
                                                               pAllocator: *const VkAllocationCallbacks,
                                                               pDescriptorPool: *mut VkDescriptorPool) -> VkResult;

pub type vkDestroyDescriptorPoolFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                descriptorPool: VkDescriptorPool,
                                                                pAllocator: *const VkAllocationCallbacks);

pub type vkResetDescriptorPoolFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                              descriptorPool: VkDescriptorPool,
                                                              flags: VkDescriptorPoolResetFlags) -> VkResult;

pub type vkAllocateDescriptorSetsFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                 pAllocateInfo: *const VkDescriptorSetAllocateInfo,
                                                                 pDescriptorSets: *mut VkDescriptorSet) -> VkResult;

pub type vkFreeDescriptorSetsFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                             descriptorPool: VkDescriptorPool,
                                                             descriptorSetCount: uint32_t,
                                                             pDescriptorSets: *const VkDescriptorSet) -> VkResult;

pub type vkUpdateDescriptorSetsFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                               descriptorWriteCount: uint32_t,
                                                               pDescriptorWrites: *const VkWriteDescriptorSet,
                                                               descriptorCopyCount: uint32_t,
                                                               pDescriptorCopies: *const VkCopyDescriptorSet);

pub type vkCreateFramebufferFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                            pCreateInfo: *const VkFramebufferCreateInfo,
                                                            pAllocator: *const VkAllocationCallbacks,
                                                            pFramebuffer: *mut VkFramebuffer) -> VkResult;

pub type vkDestroyFramebufferFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                             framebuffer: VkFramebuffer,
                                                             pAllocator: *const VkAllocationCallbacks);

pub type vkCreateRenderPassFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                           pCreateInfo: *const VkRenderPassCreateInfo,
                                                           pAllocator: *const VkAllocationCallbacks,
                                                           pRenderPass: *mut VkRenderPass) -> VkResult;

pub type vkDestroyRenderPassFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                            renderPass: VkRenderPass,
                                                            pAllocator: *const VkAllocationCallbacks);

pub type vkGetRenderAreaGranularityFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                   renderPass: VkRenderPass,
                                                                   pGranularity: *mut VkExtent2D);

pub type vkCreateCommandPoolFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                            pCreateInfo: *const VkCommandPoolCreateInfo,
                                                            pAllocator: *const VkAllocationCallbacks,
                                                            pCommandPool: *mut VkCommandPool) -> VkResult;

pub type vkDestroyCommandPoolFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                             commandPool: VkCommandPool,
                                                             pAllocator: *const VkAllocationCallbacks);

pub type vkResetCommandPoolFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                           commandPool: VkCommandPool,
                                                           flags: VkCommandPoolResetFlags) -> VkResult;

pub type vkAllocateCommandBuffersFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                                 pAllocateInfo: *const VkCommandBufferAllocateInfo,
                                                                 pCommandBuffers: *mut VkCommandBuffer) -> VkResult;

pub type vkFreeCommandBuffersFn = unsafe extern "stdcall" fn(device: VkDevice,
                                                             commandPool: VkCommandPool,
                                                             commandBufferCount: uint32_t,
                                                             pCommandBuffers: *const VkCommandBuffer);

pub type vkBeginCommandBufferFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                             pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult;

pub type vkEndCommandBufferFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer) -> VkResult;

pub type vkResetCommandBufferFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                             flags: VkCommandBufferResetFlags) -> VkResult;

pub type vkCmdBindPipelineFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                          pipelineBindPoint: VkPipelineBindPoint,
                                                          pipeline: VkPipeline);

pub type vkCmdSetViewportFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                         firstViewport: uint32_t,
                                                         viewportCount: uint32_t,
                                                         pViewports: *const VkViewport);

pub type vkCmdSetScissorFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                        firstScissor: uint32_t,
                                                        scissorCount: uint32_t,
                                                        pScissors: *const VkRect2D);

pub type vkCmdSetLineWidthFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                          lineWidth: c_float);

pub type vkCmdSetDepthBiasFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                          depthBiasConstantFactor: c_float,
                                                          depthBiasClamp: c_float,
                                                          depthBiasSlopeFactor: c_float);

// TODO: make sure this is working
pub type vkCmdSetBlendConstantsFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                               blendConstants: [c_float;4]);

pub type vkCmdSetDepthBoundsFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                            minDepthBounds: c_float,
                                                            maxDepthBounds: c_float);

pub type vkCmdSetStencilCompareMaskFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                                   faceMask: VkStencilFaceFlags,
                                                                   compareMask: uint32_t);

pub type vkCmdSetStencilWriteMaskFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                                 faceMask: VkStencilFaceFlags,
                                                                 writeMask: uint32_t);

pub type vkCmdSetStencilReferenceFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                                 faceMask: VkStencilFaceFlags,
                                                                 reference: uint32_t);

pub type vkCmdBindDescriptorSetsFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                                pipelineBindPoint: VkPipelineBindPoint,
                                                                layout: VkPipelineLayout,
                                                                firstSet: uint32_t,
                                                                descriptorSetCount: uint32_t,
                                                                pDescriptorSets: *const VkDescriptorSet,
                                                                dynamicOffsetCount: uint32_t,
                                                                pDynamicOffsets: *const uint32_t);

pub type vkCmdBindIndexBufferFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                             buffer: VkBuffer,
                                                             offset: VkDeviceSize,
                                                             indexType: VkIndexType);

pub type vkCmdBindVertexBuffersFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                               firstBinding: uint32_t,
                                                               bindingCount: uint32_t,
                                                               pBuffers: *const VkBuffer,
                                                               pOffsets: *const VkDeviceSize);

pub type vkCmdDrawFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                  vertexCount: uint32_t,
                                                  instanceCount: uint32_t,
                                                  firstVertex: uint32_t,
                                                  firstInstance: uint32_t);

pub type vkCmdDrawIndexedFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                         indexCount: uint32_t,
                                                         instanceCount: uint32_t,
                                                         firstIndex: uint32_t,
                                                         vertexOffset: int32_t,
                                                         firstInstance: uint32_t);

pub type vkCmdDrawIndirectFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                          buffer: VkBuffer,
                                                          offset: VkDeviceSize,
                                                          drawCount: uint32_t,
                                                          stride: uint32_t);

pub type vkCmdDrawIndexedIndirectFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                                 buffer: VkBuffer,
                                                                 offset: VkDeviceSize,
                                                                 drawCount: uint32_t,
                                                                 stride: uint32_t);

pub type vkCmdDispatchFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                      x: uint32_t,
                                                      y: uint32_t,
                                                      z: uint32_t);

pub type vkCmdDispatchIndirectFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                              buffer: VkBuffer,
                                                              offset: VkDeviceSize);

pub type vkCmdCopyBufferFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                        srcBuffer: VkBuffer,
                                                        dstBuffer: VkBuffer,
                                                        regionCount: uint32_t,
                                                        pRegions: *const VkBufferCopy);

pub type vkCmdCopyImageFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                       srcImage: VkImage,
                                                       srcImageLayout: VkImageLayout,
                                                       dstImage: VkImage,
                                                       dstImageLayout: VkImageLayout,
                                                       regionCount: uint32_t,
                                                       pRegions: *const VkImageCopy);

pub type vkCmdBlitImageFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                       srcImage: VkImage,
                                                       srcImageLayout: VkImageLayout,
                                                       dstImage: VkImage,
                                                       dstImageLayout: VkImageLayout,
                                                       regionCount: uint32_t,
                                                       pRegions: *const VkImageBlit,
                                                       filter: VkFilter);

pub type vkCmdCopyBufferToImageFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                               srcBuffer: VkBuffer,
                                                               dstImage: VkImage,
                                                               dstImageLayout: VkImageLayout,
                                                               regionCount: uint32_t,
                                                               pRegions: *const VkBufferImageCopy);

pub type vkCmdCopyImageToBufferFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                               srcImage: VkImage,
                                                               srcImageLayout: VkImageLayout,
                                                               dstBuffer: VkBuffer,
                                                               regionCount: uint32_t,
                                                               pRegions: *const VkBufferImageCopy);

pub type vkCmdUpdateBufferFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                          dstBuffer: VkBuffer,
                                                          dstOffset: VkDeviceSize,
                                                          dataSize: VkDeviceSize,
                                                          pData: *const uint32_t);

pub type vkCmdFillBufferFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                        dstBuffer: VkBuffer,
                                                        dstOffset: VkDeviceSize,
                                                        size: VkDeviceSize,
                                                        data: uint32_t);

pub type vkCmdClearColorImageFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                             image: VkImage,
                                                             imageLayout: VkImageLayout,
                                                             pColor: *const VkClearColorValue,
                                                             rangeCount: uint32_t,
                                                             pRanges: *const VkImageSubresourceRange);

pub type vkCmdClearDepthStencilImageFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                                    image: VkImage,
                                                                    imageLayout: VkImageLayout,
                                                                    pDepthStencil: *const VkClearDepthStencilValue,
                                                                    rangeCount: uint32_t,
                                                                    pRanges: *const VkImageSubresourceRange);

pub type vkCmdClearAttachmentsFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                              attachmentCount: uint32_t,
                                                              pAttachments: *const VkClearAttachment,
                                                              rectCount: uint32_t,
                                                              pRects: *const VkClearRect);

pub type vkCmdResolveImageFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                          srcImage: VkImage,
                                                          srcImageLayout: VkImageLayout,
                                                          dstImage: VkImage,
                                                          dstImageLayout: VkImageLayout,
                                                          regionCount: uint32_t,
                                                          pRegions: *const VkImageResolve);

pub type vkCmdSetEventFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                      event: VkEvent,
                                                      stageMask: VkPipelineStageFlags);

pub type vkCmdResetEventFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                        event: VkEvent,
                                                        stageMask: VkPipelineStageFlags);

pub type vkCmdWaitEventsFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                        eventCount: uint32_t,
                                                        pEvents: *const VkEvent,
                                                        srcStageMask: VkPipelineStageFlags,
                                                        dstStageMask: VkPipelineStageFlags,
                                                        memoryBarrierCount: uint32_t,
                                                        pMemoryBarriers: *const VkMemoryBarrier,
                                                        bufferMemoryBarrierCount: uint32_t,
                                                        pBufferMemoryBarriers: *const VkBufferMemoryBarrier,
                                                        imageMemoryBarrierCount: uint32_t,
                                                        pImageMemoryBarriers: *const VkImageMemoryBarrier);

pub type vkCmdPipelineBarrierFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                             srcStageMask: VkPipelineStageFlags,
                                                             dstStageMask: VkPipelineStageFlags,
                                                             dependencyFlags: VkDependencyFlags,
                                                             memoryBarrierCount: uint32_t,
                                                             pMemoryBarriers: *const VkMemoryBarrier,
                                                             bufferMemoryBarrierCount: uint32_t,
                                                             pBufferMemoryBarriers: *const VkBufferMemoryBarrier,
                                                             imageMemoryBarrierCount: uint32_t,
                                                             pImageMemoryBarriers: *const VkImageMemoryBarrier);

pub type vkCmdBeginQueryFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                        queryPool: VkQueryPool,
                                                        query: uint32_t,
                                                        flags: VkQueryControlFlags);

pub type vkCmdEndQueryFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                      queryPool: VkQueryPool,
                                                      query: uint32_t);

pub type vkCmdResetQueryPoolFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                            queryPool: VkQueryPool,
                                                            firstQuery: uint32_t,
                                                            queryCount: uint32_t);

pub type vkCmdWriteTimestampFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                            pipelineStage: VkPipelineStageFlagBits,
                                                            queryPool: VkQueryPool,
                                                            query: uint32_t);

pub type vkCmdCopyQueryPoolResultsFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                                  queryPool: VkQueryPool,
                                                                  firstQuery: uint32_t,
                                                                  queryCount: uint32_t,
                                                                  dstBuffer: VkBuffer,
                                                                  dstOffset: VkDeviceSize,
                                                                  stride: VkDeviceSize,
                                                                  flags: VkQueryResultFlags);

pub type vkCmdPushConstantsFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                           layout: VkPipelineLayout,
                                                           stageFlags: VkShaderStageFlags,
                                                           offset: uint32_t,
                                                           size: uint32_t,
                                                           pValues: *const c_void);

pub type vkCmdBeginRenderPassFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                             pRenderPassBegin: *const VkRenderPassBeginInfo,
                                                             contents: VkSubpassContents);

pub type vkCmdNextSubpassFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                         contents: VkSubpassContents);

pub type vkCmdEndRenderPassFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer);

pub type vkCmdExecuteCommandsFn = unsafe extern "stdcall" fn(commandBuffer: VkCommandBuffer,
                                                             commandBufferCount: uint32_t,
                                                             pCommandBuffers: *const VkCommandBuffer);

#[derive(Default)]
pub struct VulkanCore {
    library: Option<DynamicLibrary>,
    vkCreateInstance: Option<vkCreateInstanceFn>,
    vkDestroyInstance: Option<vkDestroyInstanceFn>,
    vkEnumeratePhysicalDevices: Option<vkEnumeratePhysicalDevicesFn>,
    vkGetPhysicalDeviceFeatures: Option<vkGetPhysicalDeviceFeaturesFn>,
    vkGetPhysicalDeviceFormatProperties: Option<vkGetPhysicalDeviceFormatPropertiesFn>,
    vkGetPhysicalDeviceImageFormatProperties: Option<vkGetPhysicalDeviceImageFormatPropertiesFn>,
    vkGetPhysicalDeviceProperties: Option<vkGetPhysicalDevicePropertiesFn>,
    vkGetPhysicalDeviceQueueFamilyProperties: Option<vkGetPhysicalDeviceQueueFamilyPropertiesFn>,
    vkGetPhysicalDeviceMemoryProperties: Option<vkGetPhysicalDeviceMemoryPropertiesFn>,
    vkGetInstanceProcAddr: Option<vkGetInstanceProcAddrFn>,
    vkGetDeviceProcAddr: Option<vkGetDeviceProcAddrFn>,
    vkCreateDevice: Option<vkCreateDeviceFn>,
    vkDestroyDevice: Option<vkDestroyDeviceFn>,
    vkEnumerateInstanceExtensionProperties: Option<vkEnumerateInstanceExtensionPropertiesFn>,
    vkEnumerateDeviceExtensionProperties: Option<vkEnumerateDeviceExtensionPropertiesFn>,
    vkEnumerateInstanceLayerProperties: Option<vkEnumerateInstanceLayerPropertiesFn>,
    vkEnumerateDeviceLayerProperties: Option<vkEnumerateDeviceLayerPropertiesFn>,
    vkGetDeviceQueue: Option<vkGetDeviceQueueFn>,
    vkQueueSubmit: Option<vkQueueSubmitFn>,
    vkQueueWaitIdle: Option<vkQueueWaitIdleFn>,
    vkDeviceWaitIdle: Option<vkDeviceWaitIdleFn>,
    vkAllocateMemory: Option<vkAllocateMemoryFn>,
    vkFreeMemory: Option<vkFreeMemoryFn>,
    vkMapMemory: Option<vkMapMemoryFn>,
    vkUnmapMemory: Option<vkUnmapMemoryFn>,
    vkFlushMappedMemoryRanges: Option<vkFlushMappedMemoryRangesFn>,
    vkInvalidateMappedMemoryRanges: Option<vkInvalidateMappedMemoryRangesFn>,
    vkGetDeviceMemoryCommitment: Option<vkGetDeviceMemoryCommitmentFn>,
    vkBindBufferMemory: Option<vkBindBufferMemoryFn>,
    vkBindImageMemory: Option<vkBindImageMemoryFn>,
    vkGetBufferMemoryRequirements: Option<vkGetBufferMemoryRequirementsFn>,
    vkGetImageMemoryRequirements: Option<vkGetImageMemoryRequirementsFn>,
    vkGetImageSparseMemoryRequirements: Option<vkGetImageSparseMemoryRequirementsFn>,
    vkGetPhysicalDeviceSparseImageFormatProperties: Option<vkGetPhysicalDeviceSparseImageFormatPropertiesFn>,
    vkQueueBindSparse: Option<vkQueueBindSparseFn>,
    vkCreateFence: Option<vkCreateFenceFn>,
    vkDestroyFence: Option<vkDestroyFenceFn>,
    vkResetFences: Option<vkResetFencesFn>,
    vkGetFenceStatus: Option<vkGetFenceStatusFn>,
    vkWaitForFences: Option<vkWaitForFencesFn>,
    vkCreateSemaphore: Option<vkCreateSemaphoreFn>,
    vkDestroySemaphore: Option<vkDestroySemaphoreFn>,
    vkCreateEvent: Option<vkCreateEventFn>,
    vkDestroyEvent: Option<vkDestroyEventFn>,
    vkGetEventStatus: Option<vkGetEventStatusFn>,
    vkSetEvent: Option<vkSetEventFn>,
    vkResetEvent: Option<vkResetEventFn>,
    vkCreateQueryPool: Option<vkCreateQueryPoolFn>,
    vkDestroyQueryPool: Option<vkDestroyQueryPoolFn>,
    vkGetQueryPoolResults: Option<vkGetQueryPoolResultsFn>,
    vkCreateBuffer: Option<vkCreateBufferFn>,
    vkDestroyBuffer: Option<vkDestroyBufferFn>,
    vkCreateBufferView: Option<vkCreateBufferViewFn>,
    vkDestroyBufferView: Option<vkDestroyBufferViewFn>,
    vkCreateImage: Option<vkCreateImageFn>,
    vkDestroyImage: Option<vkDestroyImageFn>,
    vkGetImageSubresourceLayout: Option<vkGetImageSubresourceLayoutFn>,
    vkCreateImageView: Option<vkCreateImageViewFn>,
    vkDestroyImageView: Option<vkDestroyImageViewFn>,
    vkCreateShaderModule: Option<vkCreateShaderModuleFn>,
    vkDestroyShaderModule: Option<vkDestroyShaderModuleFn>,
    vkCreatePipelineCache: Option<vkCreatePipelineCacheFn>,
    vkDestroyPipelineCache: Option<vkDestroyPipelineCacheFn>,
    vkGetPipelineCacheData: Option<vkGetPipelineCacheDataFn>,
    vkMergePipelineCaches: Option<vkMergePipelineCachesFn>,
    vkCreateGraphicsPipelines: Option<vkCreateGraphicsPipelinesFn>,
    vkCreateComputePipelines: Option<vkCreateComputePipelinesFn>,
    vkDestroyPipeline: Option<vkDestroyPipelineFn>,
    vkCreatePipelineLayout: Option<vkCreatePipelineLayoutFn>,
    vkDestroyPipelineLayout: Option<vkDestroyPipelineLayoutFn>,
    vkCreateSampler: Option<vkCreateSamplerFn>,
    vkDestroySampler: Option<vkDestroySamplerFn>,
    vkCreateDescriptorSetLayout: Option<vkCreateDescriptorSetLayoutFn>,
    vkDestroyDescriptorSetLayout: Option<vkDestroyDescriptorSetLayoutFn>,
    vkCreateDescriptorPool: Option<vkCreateDescriptorPoolFn>,
    vkDestroyDescriptorPool: Option<vkDestroyDescriptorPoolFn>,
    vkResetDescriptorPool: Option<vkResetDescriptorPoolFn>,
    vkAllocateDescriptorSets: Option<vkAllocateDescriptorSetsFn>,
    vkFreeDescriptorSets: Option<vkFreeDescriptorSetsFn>,
    vkUpdateDescriptorSets: Option<vkUpdateDescriptorSetsFn>,
    vkCreateFramebuffer: Option<vkCreateFramebufferFn>,
    vkDestroyFramebuffer: Option<vkDestroyFramebufferFn>,
    vkCreateRenderPass: Option<vkCreateRenderPassFn>,
    vkDestroyRenderPass: Option<vkDestroyRenderPassFn>,
    vkGetRenderAreaGranularity: Option<vkGetRenderAreaGranularityFn>,
    vkCreateCommandPool: Option<vkCreateCommandPoolFn>,
    vkDestroyCommandPool: Option<vkDestroyCommandPoolFn>,
    vkResetCommandPool: Option<vkResetCommandPoolFn>,
    vkAllocateCommandBuffers: Option<vkAllocateCommandBuffersFn>,
    vkFreeCommandBuffers: Option<vkFreeCommandBuffersFn>,
    vkBeginCommandBuffer: Option<vkBeginCommandBufferFn>,
    vkEndCommandBuffer: Option<vkEndCommandBufferFn>,
    vkResetCommandBuffer: Option<vkResetCommandBufferFn>,
    vkCmdBindPipeline: Option<vkCmdBindPipelineFn>,
    vkCmdSetViewport: Option<vkCmdSetViewportFn>,
    vkCmdSetScissor: Option<vkCmdSetScissorFn>,
    vkCmdSetLineWidth: Option<vkCmdSetLineWidthFn>,
    vkCmdSetDepthBias: Option<vkCmdSetDepthBiasFn>,
    vkCmdSetBlendConstants: Option<vkCmdSetBlendConstantsFn>,
    vkCmdSetDepthBounds: Option<vkCmdSetDepthBoundsFn>,
    vkCmdSetStencilCompareMask: Option<vkCmdSetStencilCompareMaskFn>,
    vkCmdSetStencilWriteMask: Option<vkCmdSetStencilWriteMaskFn>,
    vkCmdSetStencilReference: Option<vkCmdSetStencilReferenceFn>,
    vkCmdBindDescriptorSets: Option<vkCmdBindDescriptorSetsFn>,
    vkCmdBindIndexBuffer: Option<vkCmdBindIndexBufferFn>,
    vkCmdBindVertexBuffers: Option<vkCmdBindVertexBuffersFn>,
    vkCmdDraw: Option<vkCmdDrawFn>,
    vkCmdDrawIndexed: Option<vkCmdDrawIndexedFn>,
    vkCmdDrawIndirect: Option<vkCmdDrawIndirectFn>,
    vkCmdDrawIndexedIndirect: Option<vkCmdDrawIndexedIndirectFn>,
    vkCmdDispatch: Option<vkCmdDispatchFn>,
    vkCmdDispatchIndirect: Option<vkCmdDispatchIndirectFn>,
    vkCmdCopyBuffer: Option<vkCmdCopyBufferFn>,
    vkCmdCopyImage: Option<vkCmdCopyImageFn>,
    vkCmdBlitImage: Option<vkCmdBlitImageFn>,
    vkCmdCopyBufferToImage: Option<vkCmdCopyBufferToImageFn>,
    vkCmdCopyImageToBuffer: Option<vkCmdCopyImageToBufferFn>,
    vkCmdUpdateBuffer: Option<vkCmdUpdateBufferFn>,
    vkCmdFillBuffer: Option<vkCmdFillBufferFn>,
    vkCmdClearColorImage: Option<vkCmdClearColorImageFn>,
    vkCmdClearDepthStencilImage: Option<vkCmdClearDepthStencilImageFn>,
    vkCmdClearAttachments: Option<vkCmdClearAttachmentsFn>,
    vkCmdResolveImage: Option<vkCmdResolveImageFn>,
    vkCmdSetEvent: Option<vkCmdSetEventFn>,
    vkCmdResetEvent: Option<vkCmdResetEventFn>,
    vkCmdWaitEvents: Option<vkCmdWaitEventsFn>,
    vkCmdPipelineBarrier: Option<vkCmdPipelineBarrierFn>,
    vkCmdBeginQuery: Option<vkCmdBeginQueryFn>,
    vkCmdEndQuery: Option<vkCmdEndQueryFn>,
    vkCmdResetQueryPool: Option<vkCmdResetQueryPoolFn>,
    vkCmdWriteTimestamp: Option<vkCmdWriteTimestampFn>,
    vkCmdCopyQueryPoolResults: Option<vkCmdCopyQueryPoolResultsFn>,
    vkCmdPushConstants: Option<vkCmdPushConstantsFn>,
    vkCmdBeginRenderPass: Option<vkCmdBeginRenderPassFn>,
    vkCmdNextSubpass: Option<vkCmdNextSubpassFn>,
    vkCmdEndRenderPass: Option<vkCmdEndRenderPassFn>,
    vkCmdExecuteCommands: Option<vkCmdExecuteCommandsFn>,
}

#[cfg(windows)]
static VULKAN_LIBRARY: &'static str = "vulkan-1.dll";

#[cfg(unix)]
static VULKAN_LIBRARY: &'static str = "libvulkan-1.so";

impl VulkanCore {
    pub fn new() -> Result<VulkanCore, String> {
        let mut vulkan_core: VulkanCore = Default::default();
        let library_path = Path::new(VULKAN_LIBRARY);
        vulkan_core.library = match DynamicLibrary::open(Some(library_path)) {
            Err(error) => return Err(format!("Failed to load {}: {}", VULKAN_LIBRARY, error)),
            Ok(library) => Some(library),
        };
        unsafe {
            vulkan_core.vkGetInstanceProcAddr = Some(std::mem::transmute(try!(vulkan_core.library.as_ref().unwrap().symbol::<u8>("vkGetInstanceProcAddr"))));
            vulkan_core.vkCreateInstance = Some(std::mem::transmute(try!(vulkan_core.load_command(VkInstance::null(), "vkCreateInstance"))));
            vulkan_core.vkEnumerateInstanceExtensionProperties = Some(std::mem::transmute(try!(vulkan_core.load_command(VkInstance::null(), "vkEnumerateInstanceExtensionProperties"))));
            vulkan_core.vkEnumerateInstanceLayerProperties = Some(std::mem::transmute(try!(vulkan_core.load_command(VkInstance::null(), "vkEnumerateInstanceLayerProperties"))));
        }
        Ok(vulkan_core)
    }

    unsafe fn load_command(&self, instance: VkInstance, name: &str) -> Result<vkVoidFunctionFn, String> {
        let fn_ptr = (self.vkGetInstanceProcAddr.as_ref().unwrap())(instance, CString::new(name).unwrap().as_ptr());
        if fn_ptr != std::ptr::null() {
            Ok(fn_ptr)
        } else {
            Err(format!("Failed to load {}",name))
        }
    }

    pub fn load(&mut self, instance: VkInstance) -> Result<(), String> {
        unsafe {
            //self.vkCreateInstance = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateInstance"))));
            self.vkDestroyInstance = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyInstance"))));
            self.vkEnumeratePhysicalDevices = Some(std::mem::transmute(try!(self.load_command(instance, "vkEnumeratePhysicalDevices"))));
            self.vkGetPhysicalDeviceFeatures = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetPhysicalDeviceFeatures"))));
            self.vkGetPhysicalDeviceFormatProperties = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetPhysicalDeviceFormatProperties"))));
            self.vkGetPhysicalDeviceImageFormatProperties = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetPhysicalDeviceImageFormatProperties"))));
            self.vkGetPhysicalDeviceProperties = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetPhysicalDeviceProperties"))));
            self.vkGetPhysicalDeviceQueueFamilyProperties = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetPhysicalDeviceQueueFamilyProperties"))));
            self.vkGetPhysicalDeviceMemoryProperties = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetPhysicalDeviceMemoryProperties"))));
            self.vkGetInstanceProcAddr = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetInstanceProcAddr"))));
            self.vkGetDeviceProcAddr = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetDeviceProcAddr"))));
            self.vkCreateDevice = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateDevice"))));
            self.vkDestroyDevice = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyDevice"))));
            //self.vkEnumerateInstanceExtensionProperties = Some(std::mem::transmute(try!(self.load_command(instance, "vkEnumerateInstanceExtensionProperties"))));
            self.vkEnumerateDeviceExtensionProperties = Some(std::mem::transmute(try!(self.load_command(instance, "vkEnumerateDeviceExtensionProperties"))));
            //self.vkEnumerateInstanceLayerProperties = Some(std::mem::transmute(try!(self.load_command(instance, "vkEnumerateInstanceLayerProperties"))));
            self.vkEnumerateDeviceLayerProperties = Some(std::mem::transmute(try!(self.load_command(instance, "vkEnumerateDeviceLayerProperties"))));
            self.vkGetDeviceQueue = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetDeviceQueue"))));
            self.vkQueueSubmit = Some(std::mem::transmute(try!(self.load_command(instance, "vkQueueSubmit"))));
            self.vkQueueWaitIdle = Some(std::mem::transmute(try!(self.load_command(instance, "vkQueueWaitIdle"))));
            self.vkDeviceWaitIdle = Some(std::mem::transmute(try!(self.load_command(instance, "vkDeviceWaitIdle"))));
            self.vkAllocateMemory = Some(std::mem::transmute(try!(self.load_command(instance, "vkAllocateMemory"))));
            self.vkFreeMemory = Some(std::mem::transmute(try!(self.load_command(instance, "vkFreeMemory"))));
            self.vkMapMemory = Some(std::mem::transmute(try!(self.load_command(instance, "vkMapMemory"))));
            self.vkUnmapMemory = Some(std::mem::transmute(try!(self.load_command(instance, "vkUnmapMemory"))));
            self.vkFlushMappedMemoryRanges = Some(std::mem::transmute(try!(self.load_command(instance, "vkFlushMappedMemoryRanges"))));
            self.vkInvalidateMappedMemoryRanges = Some(std::mem::transmute(try!(self.load_command(instance, "vkInvalidateMappedMemoryRanges"))));
            self.vkGetDeviceMemoryCommitment = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetDeviceMemoryCommitment"))));
            self.vkBindBufferMemory = Some(std::mem::transmute(try!(self.load_command(instance, "vkBindBufferMemory"))));
            self.vkBindImageMemory = Some(std::mem::transmute(try!(self.load_command(instance, "vkBindImageMemory"))));
            self.vkGetBufferMemoryRequirements = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetBufferMemoryRequirements"))));
            self.vkGetImageMemoryRequirements = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetImageMemoryRequirements"))));
            self.vkGetImageSparseMemoryRequirements = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetImageSparseMemoryRequirements"))));
            self.vkGetPhysicalDeviceSparseImageFormatProperties = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"))));
            self.vkQueueBindSparse = Some(std::mem::transmute(try!(self.load_command(instance, "vkQueueBindSparse"))));
            self.vkCreateFence = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateFence"))));
            self.vkDestroyFence = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyFence"))));
            self.vkResetFences = Some(std::mem::transmute(try!(self.load_command(instance, "vkResetFences"))));
            self.vkGetFenceStatus = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetFenceStatus"))));
            self.vkWaitForFences = Some(std::mem::transmute(try!(self.load_command(instance, "vkWaitForFences"))));
            self.vkCreateSemaphore = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateSemaphore"))));
            self.vkDestroySemaphore = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroySemaphore"))));
            self.vkCreateEvent = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateEvent"))));
            self.vkDestroyEvent = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyEvent"))));
            self.vkGetEventStatus = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetEventStatus"))));
            self.vkSetEvent = Some(std::mem::transmute(try!(self.load_command(instance, "vkSetEvent"))));
            self.vkResetEvent = Some(std::mem::transmute(try!(self.load_command(instance, "vkResetEvent"))));
            self.vkCreateQueryPool = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateQueryPool"))));
            self.vkDestroyQueryPool = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyQueryPool"))));
            self.vkGetQueryPoolResults = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetQueryPoolResults"))));
            self.vkCreateBuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateBuffer"))));
            self.vkDestroyBuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyBuffer"))));
            self.vkCreateBufferView = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateBufferView"))));
            self.vkDestroyBufferView = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyBufferView"))));
            self.vkCreateImage = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateImage"))));
            self.vkDestroyImage = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyImage"))));
            self.vkGetImageSubresourceLayout = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetImageSubresourceLayout"))));
            self.vkCreateImageView = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateImageView"))));
            self.vkDestroyImageView = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyImageView"))));
            self.vkCreateShaderModule = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateShaderModule"))));
            self.vkDestroyShaderModule = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyShaderModule"))));
            self.vkCreatePipelineCache = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreatePipelineCache"))));
            self.vkDestroyPipelineCache = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyPipelineCache"))));
            self.vkGetPipelineCacheData = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetPipelineCacheData"))));
            self.vkMergePipelineCaches = Some(std::mem::transmute(try!(self.load_command(instance, "vkMergePipelineCaches"))));
            self.vkCreateGraphicsPipelines = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateGraphicsPipelines"))));
            self.vkCreateComputePipelines = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateComputePipelines"))));
            self.vkDestroyPipeline = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyPipeline"))));
            self.vkCreatePipelineLayout = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreatePipelineLayout"))));
            self.vkDestroyPipelineLayout = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyPipelineLayout"))));
            self.vkCreateSampler = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateSampler"))));
            self.vkDestroySampler = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroySampler"))));
            self.vkCreateDescriptorSetLayout = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateDescriptorSetLayout"))));
            self.vkDestroyDescriptorSetLayout = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyDescriptorSetLayout"))));
            self.vkCreateDescriptorPool = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateDescriptorPool"))));
            self.vkDestroyDescriptorPool = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyDescriptorPool"))));
            self.vkResetDescriptorPool = Some(std::mem::transmute(try!(self.load_command(instance, "vkResetDescriptorPool"))));
            self.vkAllocateDescriptorSets = Some(std::mem::transmute(try!(self.load_command(instance, "vkAllocateDescriptorSets"))));
            self.vkFreeDescriptorSets = Some(std::mem::transmute(try!(self.load_command(instance, "vkFreeDescriptorSets"))));
            self.vkUpdateDescriptorSets = Some(std::mem::transmute(try!(self.load_command(instance, "vkUpdateDescriptorSets"))));
            self.vkCreateFramebuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateFramebuffer"))));
            self.vkDestroyFramebuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyFramebuffer"))));
            self.vkCreateRenderPass = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateRenderPass"))));
            self.vkDestroyRenderPass = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyRenderPass"))));
            self.vkGetRenderAreaGranularity = Some(std::mem::transmute(try!(self.load_command(instance, "vkGetRenderAreaGranularity"))));
            self.vkCreateCommandPool = Some(std::mem::transmute(try!(self.load_command(instance, "vkCreateCommandPool"))));
            self.vkDestroyCommandPool = Some(std::mem::transmute(try!(self.load_command(instance, "vkDestroyCommandPool"))));
            self.vkResetCommandPool = Some(std::mem::transmute(try!(self.load_command(instance, "vkResetCommandPool"))));
            self.vkAllocateCommandBuffers = Some(std::mem::transmute(try!(self.load_command(instance, "vkAllocateCommandBuffers"))));
            self.vkFreeCommandBuffers = Some(std::mem::transmute(try!(self.load_command(instance, "vkFreeCommandBuffers"))));
            self.vkBeginCommandBuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkBeginCommandBuffer"))));
            self.vkEndCommandBuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkEndCommandBuffer"))));
            self.vkResetCommandBuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkResetCommandBuffer"))));
            self.vkCmdBindPipeline = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdBindPipeline"))));
            self.vkCmdSetViewport = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdSetViewport"))));
            self.vkCmdSetScissor = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdSetScissor"))));
            self.vkCmdSetLineWidth = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdSetLineWidth"))));
            self.vkCmdSetDepthBias = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdSetDepthBias"))));
            self.vkCmdSetBlendConstants = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdSetBlendConstants"))));
            self.vkCmdSetDepthBounds = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdSetDepthBounds"))));
            self.vkCmdSetStencilCompareMask = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdSetStencilCompareMask"))));
            self.vkCmdSetStencilWriteMask = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdSetStencilWriteMask"))));
            self.vkCmdSetStencilReference = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdSetStencilReference"))));
            self.vkCmdBindDescriptorSets = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdBindDescriptorSets"))));
            self.vkCmdBindIndexBuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdBindIndexBuffer"))));
            self.vkCmdBindVertexBuffers = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdBindVertexBuffers"))));
            self.vkCmdDraw = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdDraw"))));
            self.vkCmdDrawIndexed = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdDrawIndexed"))));
            self.vkCmdDrawIndirect = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdDrawIndirect"))));
            self.vkCmdDrawIndexedIndirect = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdDrawIndexedIndirect"))));
            self.vkCmdDispatch = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdDispatch"))));
            self.vkCmdDispatchIndirect = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdDispatchIndirect"))));
            self.vkCmdCopyBuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdCopyBuffer"))));
            self.vkCmdCopyImage = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdCopyImage"))));
            self.vkCmdBlitImage = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdBlitImage"))));
            self.vkCmdCopyBufferToImage = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdCopyBufferToImage"))));
            self.vkCmdCopyImageToBuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdCopyImageToBuffer"))));
            self.vkCmdUpdateBuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdUpdateBuffer"))));
            self.vkCmdFillBuffer = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdFillBuffer"))));
            self.vkCmdClearColorImage = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdClearColorImage"))));
            self.vkCmdClearDepthStencilImage = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdClearDepthStencilImage"))));
            self.vkCmdClearAttachments = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdClearAttachments"))));
            self.vkCmdResolveImage = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdResolveImage"))));
            self.vkCmdSetEvent = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdSetEvent"))));
            self.vkCmdResetEvent = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdResetEvent"))));
            self.vkCmdWaitEvents = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdWaitEvents"))));
            self.vkCmdPipelineBarrier = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdPipelineBarrier"))));
            self.vkCmdBeginQuery = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdBeginQuery"))));
            self.vkCmdEndQuery = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdEndQuery"))));
            self.vkCmdResetQueryPool = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdResetQueryPool"))));
            self.vkCmdWriteTimestamp = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdWriteTimestamp"))));
            self.vkCmdCopyQueryPoolResults = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdCopyQueryPoolResults"))));
            self.vkCmdPushConstants = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdPushConstants"))));
            self.vkCmdBeginRenderPass = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdBeginRenderPass"))));
            self.vkCmdNextSubpass = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdNextSubpass"))));
            self.vkCmdEndRenderPass = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdEndRenderPass"))));
            self.vkCmdExecuteCommands = Some(std::mem::transmute(try!(self.load_command(instance, "vkCmdExecuteCommands"))));
        }
        Ok(())
    }

    pub unsafe fn vkCreateInstance(&self, pCreateInfo: *const VkInstanceCreateInfo, pAllocator: *const VkAllocationCallbacks, pInstance: *mut VkInstance) -> VkResult {
        (self.vkCreateInstance.as_ref().unwrap())(pCreateInfo, pAllocator, pInstance)
    }

    pub unsafe fn vkDestroyInstance(&self, instance: VkInstance, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyInstance.as_ref().unwrap())(instance, pAllocator)
    }

    pub unsafe fn vkEnumeratePhysicalDevices(&self, instance: VkInstance, pPhysicalDeviceCount: *mut uint32_t, pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult {
        (self.vkEnumeratePhysicalDevices.as_ref().unwrap())(instance, pPhysicalDeviceCount, pPhysicalDevices)
    }

    pub unsafe fn vkGetPhysicalDeviceFeatures(&self, physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures) {
        (self.vkGetPhysicalDeviceFeatures.as_ref().unwrap())(physicalDevice, pFeatures)
    }

    pub unsafe fn vkGetPhysicalDeviceFormatProperties(&self, physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties) {
        (self.vkGetPhysicalDeviceFormatProperties.as_ref().unwrap())(physicalDevice, format, pFormatProperties)
    }

    pub unsafe fn vkGetPhysicalDeviceImageFormatProperties(&self, physicalDevice: VkPhysicalDevice, format: VkFormat, iType: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult {
        (self.vkGetPhysicalDeviceImageFormatProperties.as_ref().unwrap())(physicalDevice, format, iType, tiling, usage, flags, pImageFormatProperties)
    }

    pub unsafe fn vkGetPhysicalDeviceProperties(&self, physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties) {
        (self.vkGetPhysicalDeviceProperties.as_ref().unwrap())(physicalDevice, pProperties)
    }

    pub unsafe fn vkGetPhysicalDeviceQueueFamilyProperties(&self, physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut uint32_t, pQueueFamilyProperties: *mut VkQueueFamilyProperties) {
        (self.vkGetPhysicalDeviceQueueFamilyProperties.as_ref().unwrap())(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties)
    }

    pub unsafe fn vkGetPhysicalDeviceMemoryProperties(&self, physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties) {
        (self.vkGetPhysicalDeviceMemoryProperties.as_ref().unwrap())(physicalDevice, pMemoryProperties)
    }

    pub unsafe fn vkGetInstanceProcAddr(&self, instance: VkInstance, pName: *const c_char) -> vkVoidFunctionFn {
        (self.vkGetInstanceProcAddr.as_ref().unwrap())(instance, pName)
    }

    pub unsafe fn vkGetDeviceProcAddr(&self, device: VkDevice, pName: *const c_char) -> vkVoidFunctionFn {
        (self.vkGetDeviceProcAddr.as_ref().unwrap())(device, pName)
    }

    pub unsafe fn vkCreateDevice(&self, physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: *const VkAllocationCallbacks, pDevice: *mut VkDevice) -> VkResult {
        (self.vkCreateDevice.as_ref().unwrap())(physicalDevice, pCreateInfo, pAllocator, pDevice)
    }

    pub unsafe fn vkDestroyDevice(&self, device: VkDevice, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyDevice.as_ref().unwrap())(device, pAllocator)
    }

    pub unsafe fn vkEnumerateInstanceExtensionProperties(&self, pLayerName: *const c_char, pPropertyCount: *mut uint32_t, pProperties: *mut VkExtensionProperties) -> VkResult {
        (self.vkEnumerateInstanceExtensionProperties.as_ref().unwrap())(pLayerName, pPropertyCount, pProperties)
    }

    pub unsafe fn vkEnumerateDeviceExtensionProperties(&self, physicalDevice: VkPhysicalDevice, pLayerName: *const c_char, pPropertyCount: *mut uint32_t, pProperties: *mut VkExtensionProperties) -> VkResult {
        (self.vkEnumerateDeviceExtensionProperties.as_ref().unwrap())(physicalDevice, pLayerName, pPropertyCount, pProperties)
    }

    pub unsafe fn vkEnumerateInstanceLayerProperties(&self, pPropertyCount: *mut uint32_t, pProperties: *mut VkLayerProperties) -> VkResult {
        (self.vkEnumerateInstanceLayerProperties.as_ref().unwrap())(pPropertyCount, pProperties)
    }

    pub unsafe fn vkEnumerateDeviceLayerProperties(&self, physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkLayerProperties) -> VkResult {
        (self.vkEnumerateDeviceLayerProperties.as_ref().unwrap())(physicalDevice, pPropertyCount, pProperties)
    }

    pub unsafe fn vkGetDeviceQueue(&self, device: VkDevice, queueFamilyIndex: uint32_t, queueIndex: uint32_t, pQueue: *mut VkQueue) {
        (self.vkGetDeviceQueue.as_ref().unwrap())(device, queueFamilyIndex, queueIndex, pQueue)
    }

    pub unsafe fn vkQueueSubmit(&self, queue: VkQueue, submitCount: uint32_t, pSubmits: *const VkSubmitInfo, fence: VkFence) -> VkResult {
        (self.vkQueueSubmit.as_ref().unwrap())(queue, submitCount, pSubmits, fence)
    }

    pub unsafe fn vkQueueWaitIdle(&self, queue: VkQueue) -> VkResult {
        (self.vkQueueWaitIdle.as_ref().unwrap())(queue)
    }

    pub unsafe fn vkDeviceWaitIdle(&self, device: VkDevice) -> VkResult {
        (self.vkDeviceWaitIdle.as_ref().unwrap())(device)
    }

    pub unsafe fn vkAllocateMemory(&self, device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory) -> VkResult {
        (self.vkAllocateMemory.as_ref().unwrap())(device, pAllocateInfo, pAllocator, pMemory)
    }

    pub unsafe fn vkFreeMemory(&self, device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks) {
        (self.vkFreeMemory.as_ref().unwrap())(device, memory, pAllocator)
    }

    pub unsafe fn vkMapMemory(&self, device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut c_void) -> VkResult {
        (self.vkMapMemory.as_ref().unwrap())(device, memory, offset, size, flags, ppData)
    }

    pub unsafe fn vkUnmapMemory(&self, device: VkDevice, memory: VkDeviceMemory) {
        (self.vkUnmapMemory.as_ref().unwrap())(device, memory)
    }

    pub unsafe fn vkFlushMappedMemoryRanges(&self, device: VkDevice, memoryRangeCount: uint32_t, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult {
        (self.vkFlushMappedMemoryRanges.as_ref().unwrap())(device, memoryRangeCount, pMemoryRanges)
    }

    pub unsafe fn vkInvalidateMappedMemoryRanges(&self, device: VkDevice, memoryRangeCount: uint32_t, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult {
        (self.vkInvalidateMappedMemoryRanges.as_ref().unwrap())(device, memoryRangeCount, pMemoryRanges)
    }

    pub unsafe fn vkGetDeviceMemoryCommitment(&self, device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: *mut VkDeviceSize) {
        (self.vkGetDeviceMemoryCommitment.as_ref().unwrap())(device, memory, pCommittedMemoryInBytes)
    }

    pub unsafe fn vkBindBufferMemory(&self, device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult {
        (self.vkBindBufferMemory.as_ref().unwrap())(device, buffer, memory, memoryOffset)
    }

    pub unsafe fn vkBindImageMemory(&self, device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult {
        (self.vkBindImageMemory.as_ref().unwrap())(device, image, memory, memoryOffset)
    }

    pub unsafe fn vkGetBufferMemoryRequirements(&self, device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements) {
        (self.vkGetBufferMemoryRequirements.as_ref().unwrap())(device, buffer, pMemoryRequirements)
    }

    pub unsafe fn vkGetImageMemoryRequirements(&self, device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements) {
        (self.vkGetImageMemoryRequirements.as_ref().unwrap())(device, image, pMemoryRequirements)
    }

    pub unsafe fn vkGetImageSparseMemoryRequirements(&self, device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: *mut uint32_t, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements) {
        (self.vkGetImageSparseMemoryRequirements.as_ref().unwrap())(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements)
    }

    pub unsafe fn vkGetPhysicalDeviceSparseImageFormatProperties(&self, physicalDevice: VkPhysicalDevice, format: VkFormat, iType: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: *mut uint32_t, pProperties: *mut VkSparseImageFormatProperties) {
        (self.vkGetPhysicalDeviceSparseImageFormatProperties.as_ref().unwrap())(physicalDevice, format, iType, samples, usage, tiling, pPropertyCount, pProperties)
    }
    pub unsafe fn vkQueueBindSparse(&self, queue: VkQueue, bindInfoCount: uint32_t, pBindInfo: *const VkBindSparseInfo, fence: VkFence) -> VkResult {
        (self.vkQueueBindSparse.as_ref().unwrap())(queue, bindInfoCount, pBindInfo, fence)
    }

    pub unsafe fn vkCreateFence(&self, device: VkDevice, pCreateInfo: *const VkFenceCreateInfo, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult {
        (self.vkCreateFence.as_ref().unwrap())(device, pCreateInfo, pAllocator, pFence)
    }

    pub unsafe fn vkDestroyFence(&self, device: VkDevice, fence: VkFence, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyFence.as_ref().unwrap())(device, fence, pAllocator)
    }

    pub unsafe fn vkResetFences(&self, device: VkDevice, fenceCount: uint32_t, pFences: *const VkFence) -> VkResult {
        (self.vkResetFences.as_ref().unwrap())(device, fenceCount, pFences)
    }

    pub unsafe fn vkGetFenceStatus(&self, device: VkDevice, fence: VkFence) -> VkResult {
        (self.vkGetFenceStatus.as_ref().unwrap())(device, fence)
    }

    pub unsafe fn vkWaitForFences(&self, device: VkDevice, fenceCount: uint32_t, pFences: *const VkFence, waitAll: VkBool32, timeout: uint64_t) -> VkResult {
        (self.vkWaitForFences.as_ref().unwrap())(device, fenceCount, pFences, waitAll, timeout)
    }

    pub unsafe fn vkCreateSemaphore(&self, device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: *const VkAllocationCallbacks, pSemaphore: *mut VkSemaphore) -> VkResult {
        (self.vkCreateSemaphore.as_ref().unwrap())(device, pCreateInfo, pAllocator, pSemaphore)
    }

    pub unsafe fn vkDestroySemaphore(&self, device: VkDevice, semaphore: VkSemaphore, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroySemaphore.as_ref().unwrap())(device, semaphore, pAllocator)
    }

    pub unsafe fn vkCreateEvent(&self, device: VkDevice, pCreateInfo: *const VkEventCreateInfo, pAllocator: *const VkAllocationCallbacks, pEvent: *mut VkEvent) -> VkResult {
        (self.vkCreateEvent.as_ref().unwrap())(device, pCreateInfo, pAllocator, pEvent)
    }

    pub unsafe fn vkDestroyEvent(&self, device: VkDevice, event: VkEvent, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyEvent.as_ref().unwrap())(device, event, pAllocator)
    }

    pub unsafe fn vkGetEventStatus(&self, device: VkDevice, event: VkEvent) -> VkResult {
        (self.vkGetEventStatus.as_ref().unwrap())(device, event)
    }

    pub unsafe fn vkSetEvent(&self, device: VkDevice, event: VkEvent) -> VkResult {
        (self.vkSetEvent.as_ref().unwrap())(device, event)
    }

    pub unsafe fn vkResetEvent(&self, device: VkDevice, event: VkEvent) -> VkResult {
        (self.vkResetEvent.as_ref().unwrap())(device, event)
    }

    pub unsafe fn vkCreateQueryPool(&self, device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pQueryPool: *mut VkQueryPool) -> VkResult {
        (self.vkCreateQueryPool.as_ref().unwrap())(device, pCreateInfo, pAllocator, pQueryPool)
    }

    pub unsafe fn vkDestroyQueryPool(&self, device: VkDevice, queryPool: VkQueryPool, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyQueryPool.as_ref().unwrap())(device, queryPool, pAllocator)
    }

    pub unsafe fn vkGetQueryPoolResults(&self, device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t, dataSize: size_t, pData: *mut c_void, stride: VkDeviceSize, flags: VkDeviceSize) -> VkResult {
        (self.vkGetQueryPoolResults.as_ref().unwrap())(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags)
    }

    pub unsafe fn vkCreateBuffer(&self, device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer) -> VkResult {
        (self.vkCreateBuffer.as_ref().unwrap())(device, pCreateInfo, pAllocator, pBuffer)
    }

    pub unsafe fn vkDestroyBuffer(&self, device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyBuffer.as_ref().unwrap())(device, buffer, pAllocator)
    }

    pub unsafe fn vkCreateBufferView(&self, device: VkDevice, pCreateInfo: *const VkBufferViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkBufferView) -> VkResult {
        (self.vkCreateBufferView.as_ref().unwrap())(device, pCreateInfo, pAllocator, pView)
    }

    pub unsafe fn vkDestroyBufferView(&self, device: VkDevice, bufferView: VkBufferView, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyBufferView.as_ref().unwrap())(device, bufferView, pAllocator)
    }

    pub unsafe fn vkCreateImage(&self, device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage) -> VkResult {
        (self.vkCreateImage.as_ref().unwrap())(device, pCreateInfo, pAllocator, pImage)
    }

    pub unsafe fn vkDestroyImage(&self, device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyImage.as_ref().unwrap())(device, image, pAllocator)
    }

    pub unsafe fn vkGetImageSubresourceLayout(&self, device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *mut VkSubresourceLayout) {
        (self.vkGetImageSubresourceLayout.as_ref().unwrap())(device, image, pSubresource, pLayout)
    }

    pub unsafe fn vkCreateImageView(&self, device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkImageView) -> VkResult {
        (self.vkCreateImageView.as_ref().unwrap())(device, pCreateInfo, pAllocator, pView)
    }

    pub unsafe fn vkDestroyImageView(&self, device: VkDevice, imageView: VkImageView, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyImageView.as_ref().unwrap())(device, imageView, pAllocator)
    }

    pub unsafe fn vkCreateShaderModule(&self, device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: *const VkAllocationCallbacks, pShaderModule: *mut VkShaderModule) -> VkResult {
        (self.vkCreateShaderModule.as_ref().unwrap())(device, pCreateInfo, pAllocator, pShaderModule)
    }

    pub unsafe fn vkDestroyShaderModule(&self, device: VkDevice, shaderModule: VkShaderModule, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyShaderModule.as_ref().unwrap())(device, shaderModule, pAllocator)
    }

    pub unsafe fn vkCreatePipelineCache(&self, device: VkDevice, pCreateInfo: *const VkPipelineCacheCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineCache: *mut VkPipelineCache) -> VkResult {
        (self.vkCreatePipelineCache.as_ref().unwrap())(device, pCreateInfo, pAllocator, pPipelineCache)
    }

    pub unsafe fn vkDestroyPipelineCache(&self, device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyPipelineCache.as_ref().unwrap())(device, pipelineCache, pAllocator)
    }

    pub unsafe fn vkGetPipelineCacheData(&self, device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: *mut size_t, pData: *mut c_void) -> VkResult {
        (self.vkGetPipelineCacheData.as_ref().unwrap())(device, pipelineCache, pDataSize, pData)
    }

    pub unsafe fn vkMergePipelineCaches(&self, device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: uint32_t, pSrcCaches: *const VkPipelineCache) -> VkResult {
        (self.vkMergePipelineCaches.as_ref().unwrap())(device, dstCache, srcCacheCount, pSrcCaches)
    }

    pub unsafe fn vkCreateGraphicsPipelines(&self, device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkGraphicsPipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult {
        (self.vkCreateGraphicsPipelines.as_ref().unwrap())(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines)
    }

    pub unsafe fn vkCreateComputePipelines(&self, device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkComputePipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult {
        (self.vkCreateComputePipelines.as_ref().unwrap())(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines)
    }

    pub unsafe fn vkDestroyPipeline(&self, device: VkDevice, pipeline: VkPipeline, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyPipeline.as_ref().unwrap())(device, pipeline, pAllocator)
    }

    pub unsafe fn vkCreatePipelineLayout(&self, device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineLayout: *mut VkPipelineLayout) -> VkResult {
        (self.vkCreatePipelineLayout.as_ref().unwrap())(device, pCreateInfo, pAllocator, pPipelineLayout)
    }

    pub unsafe fn vkDestroyPipelineLayout(&self, device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyPipelineLayout.as_ref().unwrap())(device, pipelineLayout, pAllocator)
    }

    pub unsafe fn vkCreateSampler(&self, device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: *const VkAllocationCallbacks, pSampler: *mut VkSampler) -> VkResult {
        (self.vkCreateSampler.as_ref().unwrap())(device, pCreateInfo, pAllocator, pSampler)
    }

    pub unsafe fn vkDestroySampler(&self, device: VkDevice, sampler: VkSampler, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroySampler.as_ref().unwrap())(device, sampler, pAllocator)
    }

    pub unsafe fn vkCreateDescriptorSetLayout(&self, device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pSetLayout: *mut VkDescriptorSetLayout) -> VkResult {
        (self.vkCreateDescriptorSetLayout.as_ref().unwrap())(device, pCreateInfo, pAllocator, pSetLayout)
    }

    pub unsafe fn vkDestroyDescriptorSetLayout(&self, device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyDescriptorSetLayout.as_ref().unwrap())(device, descriptorSetLayout, pAllocator)
    }

    pub unsafe fn vkCreateDescriptorPool(&self, device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorPool: *mut VkDescriptorPool) -> VkResult {
        (self.vkCreateDescriptorPool.as_ref().unwrap())(device, pCreateInfo, pAllocator, pDescriptorPool)
    }

    pub unsafe fn vkDestroyDescriptorPool(&self, device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyDescriptorPool.as_ref().unwrap())(device, descriptorPool, pAllocator)
    }

    pub unsafe fn vkResetDescriptorPool(&self, device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult {
        (self.vkResetDescriptorPool.as_ref().unwrap())(device, descriptorPool, flags)
    }

    pub unsafe fn vkAllocateDescriptorSets(&self, device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: *mut VkDescriptorSet) -> VkResult {
        (self.vkAllocateDescriptorSets.as_ref().unwrap())(device, pAllocateInfo, pDescriptorSets)
    }

    pub unsafe fn vkFreeDescriptorSets(&self, device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32_t, pDescriptorSets: *const VkDescriptorSet) -> VkResult {
        (self.vkFreeDescriptorSets.as_ref().unwrap())(device, descriptorPool, descriptorSetCount, pDescriptorSets)
    }

    pub unsafe fn vkUpdateDescriptorSets(&self, device: VkDevice, descriptorWriteCount: uint32_t, pDescriptorWrites: *const VkWriteDescriptorSet, descriptorCopyCount: uint32_t, pDescriptorCopies: *const VkCopyDescriptorSet) {
        (self.vkUpdateDescriptorSets.as_ref().unwrap())(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies)
    }

    pub unsafe fn vkCreateFramebuffer(&self, device: VkDevice, pCreateInfo: *const VkFramebufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pFramebuffer: *mut VkFramebuffer) -> VkResult {
        (self.vkCreateFramebuffer.as_ref().unwrap())(device, pCreateInfo, pAllocator, pFramebuffer)
    }

    pub unsafe fn vkDestroyFramebuffer(&self, device: VkDevice, framebuffer: VkFramebuffer, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyFramebuffer.as_ref().unwrap())(device, framebuffer, pAllocator)
    }

    pub unsafe fn vkCreateRenderPass(&self, device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult {
        (self.vkCreateRenderPass.as_ref().unwrap())(device, pCreateInfo, pAllocator, pRenderPass)
    }

    pub unsafe fn vkDestroyRenderPass(&self, device: VkDevice, renderPass: VkRenderPass, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyRenderPass.as_ref().unwrap())(device, renderPass, pAllocator)
    }

    pub unsafe fn vkGetRenderAreaGranularity(&self, device: VkDevice, renderPass: VkRenderPass, pGranularity: *mut VkExtent2D) {
        (self.vkGetRenderAreaGranularity.as_ref().unwrap())(device, renderPass, pGranularity)
    }

    pub unsafe fn vkCreateCommandPool(&self, device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pCommandPool: *mut VkCommandPool) -> VkResult {
        (self.vkCreateCommandPool.as_ref().unwrap())(device, pCreateInfo, pAllocator, pCommandPool)
    }

    pub unsafe fn vkDestroyCommandPool(&self, device: VkDevice, commandPool: VkCommandPool, pAllocator: *const VkAllocationCallbacks) {
        (self.vkDestroyCommandPool.as_ref().unwrap())(device, commandPool, pAllocator)
    }

    pub unsafe fn vkResetCommandPool(&self, device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult {
        (self.vkResetCommandPool.as_ref().unwrap())(device, commandPool, flags)
    }

    pub unsafe fn vkAllocateCommandBuffers(&self, device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: *mut VkCommandBuffer) -> VkResult {
        (self.vkAllocateCommandBuffers.as_ref().unwrap())(device, pAllocateInfo, pCommandBuffers)
    }

    pub unsafe fn vkFreeCommandBuffers(&self, device: VkDevice, commandPool: VkCommandPool, commandBufferCount: uint32_t, pCommandBuffers: *const VkCommandBuffer) {
        (self.vkFreeCommandBuffers.as_ref().unwrap())(device, commandPool, commandBufferCount, pCommandBuffers)
    }

    pub unsafe fn vkBeginCommandBuffer(&self, commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult {
        (self.vkBeginCommandBuffer.as_ref().unwrap())(commandBuffer, pBeginInfo)
    }

    pub unsafe fn vkEndCommandBuffer(&self, commandBuffer: VkCommandBuffer) -> VkResult {
        (self.vkEndCommandBuffer.as_ref().unwrap())(commandBuffer)
    }

    pub unsafe fn vkResetCommandBuffer(&self, commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult {
        (self.vkResetCommandBuffer.as_ref().unwrap())(commandBuffer, flags)
    }

    pub unsafe fn vkCmdBindPipeline(&self, commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline) {
        (self.vkCmdBindPipeline.as_ref().unwrap())(commandBuffer, pipelineBindPoint, pipeline)
    }

    pub unsafe fn vkCmdSetViewport(&self, commandBuffer: VkCommandBuffer, firstViewport: uint32_t, viewportCount: uint32_t, pViewports: *const VkViewport) {
        (self.vkCmdSetViewport.as_ref().unwrap())(commandBuffer, firstViewport, viewportCount, pViewports)
    }

    pub unsafe fn vkCmdSetScissor(&self, commandBuffer: VkCommandBuffer, firstScissor: uint32_t, scissorCount: uint32_t, pScissors: *const VkRect2D) {
        (self.vkCmdSetScissor.as_ref().unwrap())(commandBuffer, firstScissor, scissorCount, pScissors)
    }

    pub unsafe fn vkCmdSetLineWidth(&self, commandBuffer: VkCommandBuffer, lineWidth: c_float) {
        (self.vkCmdSetLineWidth.as_ref().unwrap())(commandBuffer, lineWidth)
    }

    pub unsafe fn vkCmdSetDepthBias(&self, commandBuffer: VkCommandBuffer, depthBiasConstantFactor: c_float, depthBiasClamp: c_float, depthBiasSlopeFactor: c_float) {
        (self.vkCmdSetDepthBias.as_ref().unwrap())(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor)
    }

    // TODO: make sure this is working
    pub unsafe fn vkCmdSetBlendConstants(&self, commandBuffer: VkCommandBuffer, blendConstants: [c_float; 4]) {
        (self.vkCmdSetBlendConstants.as_ref().unwrap())(commandBuffer, blendConstants)
    }

    pub unsafe fn vkCmdSetDepthBounds(&self, commandBuffer: VkCommandBuffer, minDepthBounds: c_float, maxDepthBounds: c_float) {
        (self.vkCmdSetDepthBounds.as_ref().unwrap())(commandBuffer, minDepthBounds, maxDepthBounds)
    }

    pub unsafe fn vkCmdSetStencilCompareMask(&self, commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: uint32_t) {
        (self.vkCmdSetStencilCompareMask.as_ref().unwrap())(commandBuffer, faceMask, compareMask)
    }

    pub unsafe fn vkCmdSetStencilWriteMask(&self, commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: uint32_t) {
        (self.vkCmdSetStencilWriteMask.as_ref().unwrap())(commandBuffer, faceMask, writeMask)
    }

    pub unsafe fn vkCmdSetStencilReference(&self, commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: uint32_t) {
        (self.vkCmdSetStencilReference.as_ref().unwrap())(commandBuffer, faceMask, reference)
    }

    pub unsafe fn vkCmdBindDescriptorSets(&self, commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32_t, descriptorSetCount: uint32_t, pDescriptorSets: *const VkDescriptorSet, dynamicOffsetCount: uint32_t, pDynamicOffsets: *const uint32_t) {
        (self.vkCmdBindDescriptorSets.as_ref().unwrap())(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets)
    }

    pub unsafe fn vkCmdBindIndexBuffer(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType) {
        (self.vkCmdBindIndexBuffer.as_ref().unwrap())(commandBuffer, buffer, offset, indexType)
    }

    pub unsafe fn vkCmdBindVertexBuffers(&self, commandBuffer: VkCommandBuffer, firstBinding: uint32_t, bindingCount: uint32_t, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize) {
        (self.vkCmdBindVertexBuffers.as_ref().unwrap())(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets)
    }

    pub unsafe fn vkCmdDraw(&self, commandBuffer: VkCommandBuffer, vertexCount: uint32_t, instanceCount: uint32_t, firstVertex: uint32_t, firstInstance: uint32_t) {
        (self.vkCmdDraw.as_ref().unwrap())(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance)
    }

    pub unsafe fn vkCmdDrawIndexed(&self, commandBuffer: VkCommandBuffer, indexCount: uint32_t, instanceCount: uint32_t, firstIndex: uint32_t, vertexOffset: int32_t, firstInstance: uint32_t) {
        (self.vkCmdDrawIndexed.as_ref().unwrap())(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance)
    }

    pub unsafe fn vkCmdDrawIndirect(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32_t, stride: uint32_t) {
        (self.vkCmdDrawIndirect.as_ref().unwrap())(commandBuffer, buffer, offset, drawCount, stride)
    }

    pub unsafe fn vkCmdDrawIndexedIndirect(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32_t, stride: uint32_t) {
        (self.vkCmdDrawIndexedIndirect.as_ref().unwrap())(commandBuffer, buffer, offset, drawCount, stride)
    }

    pub unsafe fn vkCmdDispatch(&self, commandBuffer: VkCommandBuffer, x: uint32_t, y: uint32_t, z: uint32_t) {
        (self.vkCmdDispatch.as_ref().unwrap())(commandBuffer, x, y, z)
    }

    pub unsafe fn vkCmdDispatchIndirect(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize) {
        (self.vkCmdDispatchIndirect.as_ref().unwrap())(commandBuffer, buffer, offset)
    }

    pub unsafe fn vkCmdCopyBuffer(&self, commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: uint32_t, pRegions: *const VkBufferCopy) {
        (self.vkCmdCopyBuffer.as_ref().unwrap())(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions)
    }

    pub unsafe fn vkCmdCopyImage(&self, commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkImageCopy) {
        (self.vkCmdCopyImage.as_ref().unwrap())(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions)
    }

    pub unsafe fn vkCmdBlitImage(&self, commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkImageBlit, filter: VkFilter) {
        (self.vkCmdBlitImage.as_ref().unwrap())(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter)
    }

    pub unsafe fn vkCmdCopyBufferToImage(&self, commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkBufferImageCopy) {
        (self.vkCmdCopyBufferToImage.as_ref().unwrap())(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions)
    }

    pub unsafe fn vkCmdCopyImageToBuffer(&self, commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: uint32_t, pRegions: *const VkBufferImageCopy) {
        (self.vkCmdCopyImageToBuffer.as_ref().unwrap())(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions)
    }

    pub unsafe fn vkCmdUpdateBuffer(&self, commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: *const uint32_t) {
        (self.vkCmdUpdateBuffer.as_ref().unwrap())(commandBuffer, dstBuffer, dstOffset, dataSize, pData)
    }

    pub unsafe fn vkCmdFillBuffer(&self, commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: uint32_t) {
        (self.vkCmdFillBuffer.as_ref().unwrap())(commandBuffer, dstBuffer, dstOffset, size, data)
    }

    pub unsafe fn vkCmdClearColorImage(&self, commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: uint32_t, pRanges: *const VkImageSubresourceRange) {
        (self.vkCmdClearColorImage.as_ref().unwrap())(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges)
    }

    pub unsafe fn vkCmdClearDepthStencilImage(&self, commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: *const VkClearDepthStencilValue, rangeCount: uint32_t, pRanges: *const VkImageSubresourceRange) {
        (self.vkCmdClearDepthStencilImage.as_ref().unwrap())(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges)
    }

    pub unsafe fn vkCmdClearAttachments(&self, commandBuffer: VkCommandBuffer, attachmentCount: uint32_t, pAttachments: *const VkClearAttachment, rectCount: uint32_t, pRects: *const VkClearRect) {
        (self.vkCmdClearAttachments.as_ref().unwrap())(commandBuffer, attachmentCount, pAttachments, rectCount, pRects)
    }

    pub unsafe fn vkCmdResolveImage(&self, commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkImageResolve) {
        (self.vkCmdResolveImage.as_ref().unwrap())(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions)
    }

    pub unsafe fn vkCmdSetEvent(&self, commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags) {
        (self.vkCmdSetEvent.as_ref().unwrap())(commandBuffer, event, stageMask)
    }

    pub unsafe fn vkCmdResetEvent(&self, commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags) {
        (self.vkCmdResetEvent.as_ref().unwrap())(commandBuffer, event, stageMask)
    }

    pub unsafe fn vkCmdWaitEvents(&self, commandBuffer: VkCommandBuffer, eventCount: uint32_t, pEvents: *const VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: uint32_t, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: uint32_t, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: uint32_t, pImageMemoryBarriers: *const VkImageMemoryBarrier) {
        (self.vkCmdWaitEvents.as_ref().unwrap())(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers)
    }

    pub unsafe fn vkCmdPipelineBarrier(&self, commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: uint32_t, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: uint32_t, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: uint32_t, pImageMemoryBarriers: *const VkImageMemoryBarrier) {
        (self.vkCmdPipelineBarrier.as_ref().unwrap())(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers)
    }

    pub unsafe fn vkCmdBeginQuery(&self, commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32_t, flags: VkQueryControlFlags) {
        (self.vkCmdBeginQuery.as_ref().unwrap())(commandBuffer, queryPool, query, flags)
    }

    pub unsafe fn vkCmdEndQuery(&self, commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32_t) {
        (self.vkCmdEndQuery.as_ref().unwrap())(commandBuffer, queryPool, query)
    }

    pub unsafe fn vkCmdResetQueryPool(&self, commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t) {
        (self.vkCmdResetQueryPool.as_ref().unwrap())(commandBuffer, queryPool, firstQuery, queryCount)
    }

    pub unsafe fn vkCmdWriteTimestamp(&self, commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: uint32_t) {
        (self.vkCmdWriteTimestamp.as_ref().unwrap())(commandBuffer, pipelineStage, queryPool, query)
    }

    pub unsafe fn vkCmdCopyQueryPoolResults(&self, commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags) {
        (self.vkCmdCopyQueryPoolResults.as_ref().unwrap())(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags)
    }

    pub unsafe fn vkCmdPushConstants(&self, commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: uint32_t, size: uint32_t, pValues: *const c_void) {
        (self.vkCmdPushConstants.as_ref().unwrap())(commandBuffer, layout, stageFlags, offset, size, pValues)
    }

    pub unsafe fn vkCmdBeginRenderPass(&self, commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, contents: VkSubpassContents) {
        (self.vkCmdBeginRenderPass.as_ref().unwrap())(commandBuffer, pRenderPassBegin, contents)
    }

    pub unsafe fn vkCmdNextSubpass(&self, commandBuffer: VkCommandBuffer, contents: VkSubpassContents) {
        (self.vkCmdNextSubpass.as_ref().unwrap())(commandBuffer, contents)
    }

    pub unsafe fn vkCmdEndRenderPass(&self, commandBuffer: VkCommandBuffer) {
        (self.vkCmdEndRenderPass.as_ref().unwrap())(commandBuffer)
    }

    pub unsafe fn vkCmdExecuteCommands(&self, commandBuffer: VkCommandBuffer, commandBufferCount: uint32_t, pCommandBuffers: *const VkCommandBuffer) {
        (self.vkCmdExecuteCommands.as_ref().unwrap())(commandBuffer, commandBufferCount, pCommandBuffers)
    }
}