blob: b4c2a61267f525b0cc5fe8c4f46cb2605c034661 [file] [log] [blame]
////////////////////////////////////////////////////////////////////////////////
// Automatically generated file. Do not modify!
////////////////////////////////////////////////////////////////////////////////
#ifndef GAPIR_VULKAN_GFX_API_H
#define GAPIR_VULKAN_GFX_API_H
#include "gfx_api.h"
#include <gapic/static_array.h>
#include <gapic/target.h>
#include <gapic/vulkan_ptr_types.h>
#include <stdint.h>
#include <string>
struct ANativeWindow;
struct Display;
struct xcb_connection_t;
struct wl_display;
struct wl_surface;
struct MirConnection;
struct MirSurface;
namespace gapir {
class Vulkan : public Api {
public:
// The unique identifier of the graphics API.
static const char* ID;
// The index of the graphics API.
static uint8_t INDEX;
// Constructor
Vulkan();
// Returns the unique identifier of the graphics API.
const char* id() const override;
// Returns the index of the graphics API.
uint8_t index() const override;
// Look-up the API function addresses for the graphics API.
void resolve();
enum class VkPipelineCacheHeaderVersion : uint32_t {
VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
};
enum class VkResult : uint32_t {
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 = 4294967295,
VK_ERROR_OUT_OF_DEVICE_MEMORY = 4294967294,
VK_ERROR_INITIALIZATION_FAILED = 4294967293,
VK_ERROR_DEVICE_LOST = 4294967292,
VK_ERROR_MEMORY_MAP_FAILED = 4294967291,
VK_ERROR_LAYER_NOT_PRESENT = 4294967290,
VK_ERROR_EXTENSION_NOT_PRESENT = 4294967289,
VK_ERROR_FEATURE_NOT_PRESENT = 4294967288,
VK_ERROR_INCOMPATIBLE_DRIVER = 4294967287,
VK_ERROR_TOO_MANY_OBJECTS = 4294967286,
VK_ERROR_FORMAT_NOT_SUPPORTED = 4294967285,
VK_ERROR_SURFACE_LOST_KHR = 3294967296,
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = 3294967295,
VK_SUBOPTIMAL_KHR = 1000001003,
VK_ERROR_OUT_OF_DATE_KHR = 3294966292,
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 3294964295,
VK_ERROR_VALIDATION_FAILED_EXT = 3294956295,
VK_ERROR_INVALID_SHADER_NV = 1000012000,
};
enum class VkStructureType : uint32_t {
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_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_NATIVE_BUFFER_ANDROID = 1000010000,
VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000,
VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
};
enum class VkSystemAllocationScope : uint32_t {
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,
};
enum class VkInternalAllocationType : uint32_t {
VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
};
enum class VkFormat : uint32_t {
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,
};
enum class VkImageType : uint32_t {
VK_IMAGE_TYPE_1D = 0,
VK_IMAGE_TYPE_2D = 1,
VK_IMAGE_TYPE_3D = 2,
};
enum class VkImageTiling : uint32_t {
VK_IMAGE_TILING_OPTIMAL = 0,
VK_IMAGE_TILING_LINEAR = 1,
};
enum class VkPhysicalDeviceType : uint32_t {
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,
};
enum class VkQueryType : uint32_t {
VK_QUERY_TYPE_OCCLUSION = 0,
VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
VK_QUERY_TYPE_TIMESTAMP = 2,
};
enum class VkSharingMode : uint32_t {
VK_SHARING_MODE_EXCLUSIVE = 0,
VK_SHARING_MODE_CONCURRENT = 1,
};
enum class VkImageLayout : uint32_t {
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,
};
enum class VkImageViewType : uint32_t {
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,
};
enum class VkComponentSwizzle : uint32_t {
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,
};
enum class VkVertexInputRate : uint32_t {
VK_VERTEX_INPUT_RATE_VERTEX = 0,
VK_VERTEX_INPUT_RATE_INSTANCE = 1,
};
enum class VkPrimitiveTopology : uint32_t {
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,
};
enum class VkPolygonMode : uint32_t {
VK_POLYGON_MODE_FILL = 0,
VK_POLYGON_MODE_LINE = 1,
VK_POLYGON_MODE_POINT = 2,
};
enum class VkFrontFace : uint32_t {
VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
VK_FRONT_FACE_CLOCKWISE = 1,
};
enum class VkCompareOp : uint32_t {
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,
};
enum class VkStencilOp : uint32_t {
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,
};
enum class VkLogicOp : uint32_t {
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,
};
enum class VkBlendFactor : uint32_t {
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,
};
enum class VkBlendOp : uint32_t {
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,
};
enum class VkDynamicState : uint32_t {
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,
};
enum class VkFilter : uint32_t {
VK_FILTER_NEAREST = 0,
VK_FILTER_LINEAR = 1,
VK_FILTER_CUBIC_IMG = 1000015000,
};
enum class VkSamplerMipmapMode : uint32_t {
VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
};
enum class VkSamplerAddressMode : uint32_t {
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,
};
enum class VkBorderColor : uint32_t {
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,
};
enum class VkDescriptorType : uint32_t {
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,
};
enum class VkAttachmentLoadOp : uint32_t {
VK_ATTACHMENT_LOAD_OP_LOAD = 0,
VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
};
enum class VkAttachmentStoreOp : uint32_t {
VK_ATTACHMENT_STORE_OP_STORE = 0,
VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
};
enum class VkPipelineBindPoint : uint32_t {
VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
VK_PIPELINE_BIND_POINT_COMPUTE = 1,
};
enum class VkCommandBufferLevel : uint32_t {
VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
};
enum class VkIndexType : uint32_t {
VK_INDEX_TYPE_UINT16 = 0,
VK_INDEX_TYPE_UINT32 = 1,
};
enum class VkSubpassContents : uint32_t {
VK_SUBPASS_CONTENTS_INLINE = 0,
VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
};
enum class VkFormatFeatureFlagBits : uint32_t {
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 1,
VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 2,
VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 4,
VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 8,
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 16,
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 32,
VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 64,
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 128,
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 256,
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 512,
VK_FORMAT_FEATURE_BLIT_SRC_BIT = 1024,
VK_FORMAT_FEATURE_BLIT_DST_BIT = 2048,
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 4096,
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 8192,
};
enum class VkImageUsageFlagBits : uint32_t {
VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 1,
VK_IMAGE_USAGE_TRANSFER_DST_BIT = 2,
VK_IMAGE_USAGE_SAMPLED_BIT = 4,
VK_IMAGE_USAGE_STORAGE_BIT = 8,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 16,
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 32,
VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 64,
VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 128,
};
enum class VkImageCreateFlagBits : uint32_t {
VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 1,
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 2,
VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 4,
VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 8,
VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 16,
};
enum class VkSampleCountFlagBits : uint32_t {
VK_SAMPLE_COUNT_1_BIT = 1,
VK_SAMPLE_COUNT_2_BIT = 2,
VK_SAMPLE_COUNT_4_BIT = 4,
VK_SAMPLE_COUNT_8_BIT = 8,
VK_SAMPLE_COUNT_16_BIT = 16,
VK_SAMPLE_COUNT_32_BIT = 32,
VK_SAMPLE_COUNT_64_BIT = 64,
};
enum class VkQueueFlagBits : uint32_t {
VK_QUEUE_GRAPHICS_BIT = 1,
VK_QUEUE_COMPUTE_BIT = 2,
VK_QUEUE_TRANSFER_BIT = 4,
VK_QUEUE_SPARSE_BINDING_BIT = 8,
};
enum class VkMemoryPropertyFlagBits : uint32_t {
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 1,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 2,
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 4,
VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 8,
VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 16,
};
enum class VkMemoryHeapFlagBits : uint32_t {
VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1,
};
enum class VkPipelineStageFlagBits : uint32_t {
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 1,
VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 2,
VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 4,
VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 8,
VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 16,
VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 32,
VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 64,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 128,
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 256,
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 512,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 1024,
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 2048,
VK_PIPELINE_STAGE_TRANSFER_BIT = 4096,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 8192,
VK_PIPELINE_STAGE_HOST_BIT = 16384,
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 32768,
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 65536,
};
enum class VkImageAspectFlagBits : uint32_t {
VK_IMAGE_ASPECT_COLOR_BIT = 1,
VK_IMAGE_ASPECT_DEPTH_BIT = 2,
VK_IMAGE_ASPECT_STENCIL_BIT = 4,
VK_IMAGE_ASPECT_METADATA_BIT = 8,
};
enum class VkSparseImageFormatFlagBits : uint32_t {
VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 1,
VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 2,
VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 4,
};
enum class VkSparseMemoryBindFlagBits : uint32_t {
VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1,
};
enum class VkFenceCreateFlagBits : uint32_t {
VK_FENCE_CREATE_SIGNALED_BIT = 1,
};
enum class VkQueryPipelineStatisticFlagBits : uint32_t {
VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 1,
VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 2,
VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 4,
VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 8,
VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 16,
VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 32,
VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 64,
VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 128,
VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 256,
VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 512,
VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 1024,
};
enum class VkQueryResultFlagBits : uint32_t {
VK_QUERY_RESULT_64_BIT = 1,
VK_QUERY_RESULT_WAIT_BIT = 2,
VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 4,
VK_QUERY_RESULT_PARTIAL_BIT = 8,
};
enum class VkBufferCreateFlagBits : uint32_t {
VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1,
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2,
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 4,
};
enum class VkBufferUsageFlagBits : uint32_t {
VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 1,
VK_BUFFER_USAGE_TRANSFER_DST_BIT = 2,
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 4,
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 8,
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 16,
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 32,
VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 64,
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 128,
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 256,
};
enum class VkPipelineCreateFlagBits : uint32_t {
VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1,
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2,
VK_PIPELINE_CREATE_DERIVATIVE_BIT = 4,
};
enum class VkShaderStageFlagBits : uint32_t {
VK_SHADER_STAGE_VERTEX_BIT = 1,
VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 2,
VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 4,
VK_SHADER_STAGE_GEOMETRY_BIT = 8,
VK_SHADER_STAGE_FRAGMENT_BIT = 16,
VK_SHADER_STAGE_COMPUTE_BIT = 32,
VK_SHADER_STAGE_ALL_GRAPHICS = 31,
VK_SHADER_STAGE_ALL = 2147483647,
};
enum class VkCullModeFlagBits : uint32_t {
VK_CULL_MODE_NONE = 0,
VK_CULL_MODE_FRONT_BIT = 1,
VK_CULL_MODE_BACK_BIT = 2,
VK_CULL_MODE_FRONT_AND_BACK = 3,
};
enum class VkColorComponentFlagBits : uint32_t {
VK_COLOR_COMPONENT_R_BIT = 1,
VK_COLOR_COMPONENT_G_BIT = 2,
VK_COLOR_COMPONENT_B_BIT = 4,
VK_COLOR_COMPONENT_A_BIT = 8,
};
enum class VkDescriptorPoolCreateFlagBits : uint32_t {
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1,
};
enum class VkAttachmentDescriptionFlagBits : uint32_t {
VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1,
};
enum class VkAccessFlagBits : uint32_t {
VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 1,
VK_ACCESS_INDEX_READ_BIT = 2,
VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 4,
VK_ACCESS_UNIFORM_READ_BIT = 8,
VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 16,
VK_ACCESS_SHADER_READ_BIT = 32,
VK_ACCESS_SHADER_WRITE_BIT = 64,
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 128,
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 256,
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 512,
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 1024,
VK_ACCESS_TRANSFER_READ_BIT = 2048,
VK_ACCESS_TRANSFER_WRITE_BIT = 4096,
VK_ACCESS_HOST_READ_BIT = 8192,
VK_ACCESS_HOST_WRITE_BIT = 16384,
VK_ACCESS_MEMORY_READ_BIT = 32768,
VK_ACCESS_MEMORY_WRITE_BIT = 65536,
};
enum class VkDependencyFlagBits : uint32_t {
VK_DEPENDENCY_BY_REGION_BIT = 1,
};
enum class VkCommandPoolCreateFlagBits : uint32_t {
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1,
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2,
};
enum class VkCommandPoolResetFlagBits : uint32_t {
VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1,
};
enum class VkCommandBufferUsageFlagBits : uint32_t {
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 1,
VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 2,
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 4,
};
enum class VkQueryControlFlagBits : uint32_t {
VK_QUERY_CONTROL_PRECISE_BIT = 1,
};
enum class VkCommandBufferResetFlagBits : uint32_t {
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1,
};
enum class VkStencilFaceFlagBits : uint32_t {
VK_STENCIL_FACE_FRONT_BIT = 1,
VK_STENCIL_FACE_BACK_BIT = 2,
VK_STENCIL_FRONT_AND_BACK = 3,
};
enum class VkExternalMemoryHandleTypeFlagBitsNV : uint32_t {
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 1,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 2,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 4,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 8,
};
enum class VkColorSpaceKHR : uint32_t {
VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0,
};
enum class VkPresentModeKHR : uint32_t {
VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
VK_PRESENT_MODE_MAILBOX_KHR = 1,
VK_PRESENT_MODE_FIFO_KHR = 2,
VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
};
enum class VkSurfaceTransformFlagBitsKHR : uint32_t {
VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 1,
VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 2,
VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 4,
VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 8,
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 16,
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 32,
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 64,
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 128,
VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 256,
};
enum class VkCompositeAlphaFlagBitsKHR : uint32_t {
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 1,
VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 2,
VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 4,
VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 8,
};
enum class VkDisplayPlaneAlphaFlagBitsKHR : uint32_t {
VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 1,
VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 2,
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 4,
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 8,
};
enum class VkDebugReportObjectTypeEXT : uint32_t {
VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28,
};
enum class VkDebugReportErrorEXT : uint32_t {
VK_DEBUG_REPORT_ERROR_NONE_EXT = 0,
VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1,
};
enum class VkDebugReportFlagBitsEXT : uint32_t {
VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 1,
VK_DEBUG_REPORT_WARNING_BIT_EXT = 2,
VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 4,
VK_DEBUG_REPORT_ERROR_BIT_EXT = 8,
VK_DEBUG_REPORT_DEBUG_BIT_EXT = 16,
};
typedef void* buffer_handle_t;
typedef uint32_t VkFlags;
typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
typedef size_val Window;
typedef size_val VisualID;
typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
typedef uint32_t xcb_window_t;
typedef uint32_t xcb_visualid_t;
typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
typedef VkFlags VkMirSurfaceCreateFlagsKHR;
typedef uint32_t VkBool32;
typedef uint64_t VkDeviceSize;
typedef uint32_t VkSampleMask;
typedef size_val VkInstance;
typedef size_val VkPhysicalDevice;
typedef size_val VkDevice;
typedef size_val VkQueue;
typedef size_val VkCommandBuffer;
typedef uint64_t VkSemaphore;
typedef uint64_t VkFence;
typedef uint64_t VkDeviceMemory;
typedef uint64_t VkBuffer;
typedef uint64_t VkImage;
typedef uint64_t VkEvent;
typedef uint64_t VkQueryPool;
typedef uint64_t VkBufferView;
typedef uint64_t VkImageView;
typedef uint64_t VkShaderModule;
typedef uint64_t VkPipelineCache;
typedef uint64_t VkPipelineLayout;
typedef uint64_t VkRenderPass;
typedef uint64_t VkPipeline;
typedef uint64_t VkDescriptorSetLayout;
typedef uint64_t VkSampler;
typedef uint64_t VkDescriptorPool;
typedef uint64_t VkDescriptorSet;
typedef uint64_t VkFramebuffer;
typedef uint64_t VkCommandPool;
typedef uint64_t VkSurfaceKHR;
typedef uint64_t VkSwapchainKHR;
typedef uint64_t VkDisplayKHR;
typedef uint64_t VkDisplayModeKHR;
typedef uint64_t VkDebugReportCallbackEXT;
typedef VkFlags VkInstanceCreateFlags;
typedef VkFlags VkFormatFeatureFlags;
typedef VkFlags VkImageUsageFlags;
typedef VkFlags VkImageCreateFlags;
typedef VkFlags VkSampleCountFlags;
typedef VkFlags VkQueueFlags;
typedef VkFlags VkMemoryPropertyFlags;
typedef VkFlags VkMemoryHeapFlags;
typedef VkFlags VkDeviceCreateFlags;
typedef VkFlags VkDeviceQueueCreateFlags;
typedef VkFlags VkPipelineStageFlags;
typedef VkFlags VkMemoryMapFlags;
typedef VkFlags VkImageAspectFlags;
typedef VkFlags VkSparseImageFormatFlags;
typedef VkFlags VkSparseMemoryBindFlags;
typedef VkFlags VkFenceCreateFlags;
typedef VkFlags VkSemaphoreCreateFlags;
typedef VkFlags VkEventCreateFlags;
typedef VkFlags VkQueryPoolCreateFlags;
typedef VkFlags VkQueryPipelineStatisticFlags;
typedef VkFlags VkQueryResultFlags;
typedef VkFlags VkBufferCreateFlags;
typedef VkFlags VkBufferUsageFlags;
typedef VkFlags VkBufferViewCreateFlags;
typedef VkFlags VkImageViewCreateFlags;
typedef VkFlags VkShaderModuleCreateFlags;
typedef VkFlags VkPipelineCacheCreateFlags;
typedef VkFlags VkPipelineCreateFlags;
typedef VkFlags VkPipelineShaderStageCreateFlags;
typedef VkFlags VkShaderStageFlags;
typedef VkFlags VkPipelineVertexInputStateCreateFlags;
typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
typedef VkFlags VkPipelineTessellationStateCreateFlags;
typedef VkFlags VkPipelineViewportStateCreateFlags;
typedef VkFlags VkPipelineRasterizationStateCreateFlags;
typedef VkFlags VkCullModeFlags;
typedef VkFlags VkPipelineMultisampleStateCreateFlags;
typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
typedef VkFlags VkPipelineColorBlendStateCreateFlags;
typedef VkFlags VkColorComponentFlags;
typedef VkFlags VkPipelineDynamicStateCreateFlags;
typedef VkFlags VkPipelineLayoutCreateFlags;
typedef VkFlags VkSamplerCreateFlags;
typedef VkFlags VkDescriptorSetLayoutCreateFlags;
typedef VkFlags VkDescriptorPoolCreateFlags;
typedef VkFlags VkDescriptorPoolResetFlags;
typedef VkFlags VkFramebufferCreateFlags;
typedef VkFlags VkRenderPassCreateFlags;
typedef VkFlags VkAttachmentDescriptionFlags;
typedef VkFlags VkSubpassDescriptionFlags;
typedef VkFlags VkAccessFlags;
typedef VkFlags VkDependencyFlags;
typedef VkFlags VkCommandPoolCreateFlags;
typedef VkFlags VkCommandPoolResetFlags;
typedef VkFlags VkCommandBufferUsageFlags;
typedef VkFlags VkQueryControlFlags;
typedef VkFlags VkCommandBufferResetFlags;
typedef VkFlags VkStencilFaceFlags;
typedef void* PFN_vkAllocationFunction;
typedef void* PFN_vkReallocationFunction;
typedef void* PFN_vkFreeFunction;
typedef void* PFN_vkInternalAllocationNotification;
typedef void* PFN_vkInternalFreeNotification;
typedef void* PFN_vkVoidFunction;
typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
typedef VkFlags VkSurfaceTransformFlagsKHR;
typedef VkFlags VkCompositeAlphaFlagsKHR;
typedef VkFlags VkSwapchainCreateFlagsKHR;
typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
typedef VkFlags VkDisplayModeCreateFlagsKHR;
typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
typedef VkFlags VkDebugReportFlagsEXT;
typedef void* PFN_vkDebugReportCallbackEXT;
typedef struct {
VkStructureType sType;
void* pNext;
VkAndroidSurfaceCreateFlagsKHR flags;
ANativeWindow* window;
} VkAndroidSurfaceCreateInfoKHR;
typedef struct {
VkStructureType sType;
void* pNext;
buffer_handle_t handle;
int stride;
int format;
int usage;
} VkNativeBufferANDROID;
typedef struct {
VkStructureType sType;
void* pNext;
VkXlibSurfaceCreateFlagsKHR flags;
Display* dpy;
Window window;
} VkXlibSurfaceCreateInfoKHR;
typedef struct {
VkStructureType sType;
void* pNext;
VkXcbSurfaceCreateFlagsKHR flags;
xcb_connection_t* connection;
xcb_window_t window;
} VkXcbSurfaceCreateInfoKHR;
typedef struct {
VkStructureType sType;
void* pNext;
VkWaylandSurfaceCreateFlagsKHR flags;
wl_display* display;
wl_surface* surface;
} VkWaylandSurfaceCreateInfoKHR;
typedef struct {
VkStructureType sType;
void* pNext;
VkMirSurfaceCreateFlagsKHR flags;
MirConnection* connection;
MirSurface* mirSurface;
} VkMirSurfaceCreateInfoKHR;
typedef struct {
VkStructureType sType;
void* pNext;
char* pApplicationName;
uint32_t applicationVersion;
char* pEngineName;
uint32_t engineVersion;
uint32_t apiVersion;
} VkApplicationInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkInstanceCreateFlags flags;
VkApplicationInfo* pApplicationInfo;
uint32_t enabledLayerCount;
char** ppEnabledLayerNames;
uint32_t enabledExtensionCount;
char** ppEnabledExtensionNames;
} VkInstanceCreateInfo;
typedef struct {
void* pUserData;
PFN_vkAllocationFunction pfnAllocation;
PFN_vkReallocationFunction pfnReallocation;
PFN_vkFreeFunction pfnFree;
PFN_vkInternalAllocationNotification pfnInternalAllocation;
PFN_vkInternalFreeNotification pfnInternalFree;
} VkAllocationCallbacks;
typedef struct {
VkBool32 robustBufferAccess;
VkBool32 fullDrawIndexUint32;
VkBool32 imageCubeArray;
VkBool32 independentBlend;
VkBool32 geometryShader;
VkBool32 tessellationShader;
VkBool32 sampleRateShading;
VkBool32 dualSrcBlend;
VkBool32 logicOp;
VkBool32 multiDrawIndirect;
VkBool32 drawIndirectFirstInstance;
VkBool32 depthClamp;
VkBool32 depthBiasClamp;
VkBool32 fillModeNonSolid;
VkBool32 depthBounds;
VkBool32 wideLines;
VkBool32 largePoints;
VkBool32 alphaToOne;
VkBool32 multiViewport;
VkBool32 samplerAnisotropy;
VkBool32 textureCompressionETC2;
VkBool32 textureCompressionASTC_LDR;
VkBool32 textureCompressionBC;
VkBool32 occlusionQueryPrecise;
VkBool32 pipelineStatisticsQuery;
VkBool32 vertexPipelineStoresAndAtomics;
VkBool32 fragmentStoresAndAtomics;
VkBool32 shaderTessellationAndGeometryPointSize;
VkBool32 shaderImageGatherExtended;
VkBool32 shaderStorageImageExtendedFormats;
VkBool32 shaderStorageImageMultisample;
VkBool32 shaderStorageImageReadWithoutFormat;
VkBool32 shaderStorageImageWriteWithoutFormat;
VkBool32 shaderUniformBufferArrayDynamicIndexing;
VkBool32 shaderSampledImageArrayDynamicIndexing;
VkBool32 shaderStorageBufferArrayDynamicIndexing;
VkBool32 shaderStorageImageArrayDynamicIndexing;
VkBool32 shaderClipDistance;
VkBool32 shaderCullDistance;
VkBool32 shaderFloat64;
VkBool32 shaderInt64;
VkBool32 shaderInt16;
VkBool32 shaderResourceResidency;
VkBool32 shaderResourceMinLod;
VkBool32 sparseBinding;
VkBool32 sparseResidencyBuffer;
VkBool32 sparseResidencyImage2D;
VkBool32 sparseResidencyImage3D;
VkBool32 sparseResidency2Samples;
VkBool32 sparseResidency4Samples;
VkBool32 sparseResidency8Samples;
VkBool32 sparseResidency16Samples;
VkBool32 sparseResidencyAliased;
VkBool32 variableMultisampleRate;
VkBool32 inheritedQueries;
} VkPhysicalDeviceFeatures;
typedef struct {
VkFormatFeatureFlags linearTilingFeatures;
VkFormatFeatureFlags optimalTilingFeatures;
VkFormatFeatureFlags bufferFeatures;
} VkFormatProperties;
typedef struct {
uint32_t width;
uint32_t height;
uint32_t depth;
} VkExtent3D;
typedef struct {
VkExtent3D maxExtent;
uint32_t maxMipLevels;
uint32_t maxArrayLayers;
VkSampleCountFlags sampleCounts;
VkDeviceSize maxResourceSize;
} VkImageFormatProperties;
typedef struct {
uint32_t maxImageDimension1D;
uint32_t maxImageDimension2D;
uint32_t maxImageDimension3D;
uint32_t maxImageDimensionCube;
uint32_t maxImageArrayLayers;
uint32_t maxTexelBufferElements;
uint32_t maxUniformBufferRange;
uint32_t maxStorageBufferRange;
uint32_t maxPushConstantsSize;
uint32_t maxMemoryAllocationCount;
uint32_t maxSamplerAllocationCount;
VkDeviceSize bufferImageGranularity;
VkDeviceSize sparseAddressSpaceSize;
uint32_t maxBoundDescriptorSets;
uint32_t maxPerStageDescriptorSamplers;
uint32_t maxPerStageDescriptorUniformBuffers;
uint32_t maxPerStageDescriptorStorageBuffers;
uint32_t maxPerStageDescriptorSampledImages;
uint32_t maxPerStageDescriptorStorageImages;
uint32_t maxPerStageDescriptorInputAttachments;
uint32_t maxPerStageResources;
uint32_t maxDescriptorSetSamplers;
uint32_t maxDescriptorSetUniformBuffers;
uint32_t maxDescriptorSetUniformBuffersDynamic;
uint32_t maxDescriptorSetStorageBuffers;
uint32_t maxDescriptorSetStorageBuffersDynamic;
uint32_t maxDescriptorSetSampledImages;
uint32_t maxDescriptorSetStorageImages;
uint32_t maxDescriptorSetInputAttachments;
uint32_t maxVertexInputAttributes;
uint32_t maxVertexInputBindings;
uint32_t maxVertexInputAttributeOffset;
uint32_t maxVertexInputBindingStride;
uint32_t maxVertexOutputComponents;
uint32_t maxTessellationGenerationLevel;
uint32_t maxTessellationPatchSize;
uint32_t maxTessellationControlPerVertexInputComponents;
uint32_t maxTessellationControlPerVertexOutputComponents;
uint32_t maxTessellationControlPerPatchOutputComponents;
uint32_t maxTessellationControlTotalOutputComponents;
uint32_t maxTessellationEvaluationInputComponents;
uint32_t maxTessellationEvaluationOutputComponents;
uint32_t maxGeometryShaderInvocations;
uint32_t maxGeometryInputComponents;
uint32_t maxGeometryOutputComponents;
uint32_t maxGeometryOutputVertices;
uint32_t maxGeometryTotalOutputComponents;
uint32_t maxFragmentInputComponents;
uint32_t maxFragmentOutputAttachments;
uint32_t maxFragmentDualSrcAttachments;
uint32_t maxFragmentCombinedOutputResources;
uint32_t maxComputeSharedMemorySize;
gapic::StaticArray<uint32_t, 3> maxComputeWorkGroupCount;
uint32_t maxComputeWorkGroupInvocations;
gapic::StaticArray<uint32_t, 3> maxComputeWorkGroupSize;
uint32_t subPixelPrecisionBits;
uint32_t subTexelPrecisionBits;
uint32_t mipmapPrecisionBits;
uint32_t maxDrawIndexedIndexValue;
uint32_t maxDrawIndirectCount;
float maxSamplerLodBias;
float maxSamplerAnisotropy;
uint32_t maxViewports;
gapic::StaticArray<uint32_t, 2> maxViewportDimensions;
gapic::StaticArray<float, 2> viewportBoundsRange;
uint32_t viewportSubPixelBits;
size_val minMemoryMapAlignment;
VkDeviceSize minTexelBufferOffsetAlignment;
VkDeviceSize minUniformBufferOffsetAlignment;
VkDeviceSize minStorageBufferOffsetAlignment;
int32_t minTexelOffset;
uint32_t maxTexelOffset;
int32_t minTexelGatherOffset;
uint32_t maxTexelGatherOffset;
float minInterpolationOffset;
float maxInterpolationOffset;
uint32_t subPixelInterpolationOffsetBits;
uint32_t maxFramebufferWidth;
uint32_t maxFramebufferHeight;
uint32_t maxFramebufferLayers;
VkSampleCountFlags framebufferColorSampleCounts;
VkSampleCountFlags framebufferDepthSampleCounts;
VkSampleCountFlags framebufferStencilSampleCounts;
VkSampleCountFlags framebufferNoAttachmentSampleCounts;
uint32_t maxColorAttachments;
VkSampleCountFlags sampledImageColorSampleCounts;
VkSampleCountFlags sampledImageIntegerSampleCounts;
VkSampleCountFlags sampledImageDepthSampleCounts;
VkSampleCountFlags sampledImageStencilSampleCounts;
VkSampleCountFlags storageImageSampleCounts;
uint32_t maxSampleMaskWords;
VkBool32 timestampComputeAndGraphics;
float timestampPeriod;
uint32_t maxClipDistances;
uint32_t maxCullDistances;
uint32_t maxCombinedClipAndCullDistances;
uint32_t discreteQueuePriorities;
gapic::StaticArray<float, 2> pointSizeRange;
gapic::StaticArray<float, 2> lineWidthRange;
float pointSizeGranularity;
float lineWidthGranularity;
VkBool32 strictLines;
VkBool32 standardSampleLocations;
VkDeviceSize optimalBufferCopyOffsetAlignment;
VkDeviceSize optimalBufferCopyRowPitchAlignment;
VkDeviceSize nonCoherentAtomSize;
} VkPhysicalDeviceLimits;
typedef struct {
VkBool32 residencyStandard2DBlockShape;
VkBool32 residencyStandard2DMultisampleBlockShape;
VkBool32 residencyStandard3DBlockShape;
VkBool32 residencyAlignedMipSize;
VkBool32 residencyNonResidentStrict;
} VkPhysicalDeviceSparseProperties;
typedef struct {
uint32_t apiVersion;
uint32_t driverVersion;
uint32_t vendorID;
uint32_t deviceID;
VkPhysicalDeviceType deviceType;
gapic::StaticArray<char, 256> deviceName;
gapic::StaticArray<uint8_t, 16> pipelineCacheUUID;
VkPhysicalDeviceLimits limits;
VkPhysicalDeviceSparseProperties sparseProperties;
} VkPhysicalDeviceProperties;
typedef struct {
VkQueueFlags queueFlags;
uint32_t queueCount;
uint32_t timestampValidBits;
VkExtent3D minImageTransferGranularity;
} VkQueueFamilyProperties;
typedef struct {
VkMemoryPropertyFlags propertyFlags;
uint32_t heapIndex;
} VkMemoryType;
typedef struct {
VkDeviceSize size;
VkMemoryHeapFlags flags;
} VkMemoryHeap;
typedef struct {
uint32_t memoryTypeCount;
gapic::StaticArray<VkMemoryType, 32> memoryTypes;
uint32_t memoryHeapCount;
gapic::StaticArray<VkMemoryHeap, 16> memoryHeaps;
} VkPhysicalDeviceMemoryProperties;
typedef struct {
VkStructureType sType;
void* pNext;
VkDeviceQueueCreateFlags flags;
uint32_t queueFamilyIndex;
uint32_t queueCount;
float* pQueuePriorities;
} VkDeviceQueueCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkDeviceCreateFlags flags;
uint32_t queueCreateInfoCount;
VkDeviceQueueCreateInfo* pQueueCreateInfos;
uint32_t enabledLayerCount;
char** ppEnabledLayerNames;
uint32_t enabledExtensionCount;
char** ppEnabledExtensionNames;
VkPhysicalDeviceFeatures* pEnabledFeatures;
} VkDeviceCreateInfo;
typedef struct {
gapic::StaticArray<char, 256> extensionName;
uint32_t specVersion;
} VkExtensionProperties;
typedef struct {
gapic::StaticArray<char, 256> layerName;
uint32_t specVersion;
uint32_t implementationVersion;
gapic::StaticArray<char, 256> description;
} VkLayerProperties;
typedef struct {
VkStructureType sType;
void* pNext;
uint32_t waitSemaphoreCount;
VkSemaphore* pWaitSemaphores;
VkPipelineStageFlags* pWaitDstStageMask;
uint32_t commandBufferCount;
VkCommandBuffer* pCommandBuffers;
uint32_t signalSemaphoreCount;
VkSemaphore* pSignalSemaphores;
} VkSubmitInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkDeviceSize allocationSize;
uint32_t memoryTypeIndex;
} VkMemoryAllocateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkDeviceMemory memory;
VkDeviceSize offset;
VkDeviceSize size;
} VkMappedMemoryRange;
typedef struct {
VkDeviceSize size;
VkDeviceSize alignment;
uint32_t memoryTypeBits;
} VkMemoryRequirements;
typedef struct {
VkImageAspectFlagBits aspectMask;
VkExtent3D imageGranularity;
VkSparseImageFormatFlags flags;
} VkSparseImageFormatProperties;
typedef struct {
VkSparseImageFormatProperties formatProperties;
uint32_t imageMipTailFirstLod;
VkDeviceSize imageMipTailSize;
VkDeviceSize imageMipTailOffset;
VkDeviceSize imageMipTailStride;
} VkSparseImageMemoryRequirements;
typedef struct {
VkDeviceSize resourceOffset;
VkDeviceSize size;
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
VkSparseMemoryBindFlags flags;
} VkSparseMemoryBind;
typedef struct {
VkBuffer buffer;
uint32_t bindCount;
VkSparseMemoryBind* pBinds;
} VkSparseBufferMemoryBindInfo;
typedef struct {
VkImage image;
uint32_t bindCount;
VkSparseMemoryBind* pBinds;
} VkSparseImageOpaqueMemoryBindInfo;
typedef struct {
VkImageAspectFlagBits aspectMask;
uint32_t mipLevel;
uint32_t arrayLayer;
} VkImageSubresource;
typedef struct {
int32_t x;
int32_t y;
int32_t z;
} VkOffset3D;
typedef struct {
VkImageSubresource subresource;
VkOffset3D offset;
VkExtent3D extent;
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
VkSparseMemoryBindFlags flags;
} VkSparseImageMemoryBind;
typedef struct {
VkImage image;
uint32_t bindCount;
VkSparseMemoryBind* pBinds;
} VkSparseImageMemoryBindInfo;
typedef struct {
VkStructureType sType;
void* pNext;
uint32_t waitSemaphoreCount;
VkSemaphore* pWaitSemaphores;
uint32_t numBufferBinds;
VkSparseBufferMemoryBindInfo* pBufferBinds;
uint32_t numImageOpaqueBinds;
VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
uint32_t numImageBinds;
VkSparseImageMemoryBindInfo* pImageBinds;
uint32_t signalSemaphoreCount;
VkSemaphore* pSignalSemaphores;
} VkBindSparseInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkFenceCreateFlags flags;
} VkFenceCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkSemaphoreCreateFlags flags;
} VkSemaphoreCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkEventCreateFlags flags;
} VkEventCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkQueryPoolCreateFlags flags;
VkQueryType queryType;
uint32_t queryCount;
VkQueryPipelineStatisticFlags pipelineStatistics;
} VkQueryPoolCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkBufferCreateFlags flags;
VkDeviceSize size;
VkBufferUsageFlags usage;
VkSharingMode sharingMode;
uint32_t queueFamilyIndexCount;
uint32_t* pQueueFamilyIndices;
} VkBufferCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkBufferViewCreateFlags flags;
VkBuffer buffer;
VkFormat format;
VkDeviceSize offset;
VkDeviceSize range;
} VkBufferViewCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkImageCreateFlags flags;
VkImageType imageType;
VkFormat format;
VkExtent3D extent;
uint32_t mipLevels;
uint32_t arrayLayers;
VkSampleCountFlagBits samples;
VkImageTiling tiling;
VkImageUsageFlags usage;
VkSharingMode sharingMode;
uint32_t queueFamilyIndexCount;
uint32_t* pQueueFamilyIndices;
VkImageLayout initialLayout;
} VkImageCreateInfo;
typedef struct {
VkDeviceSize offset;
VkDeviceSize size;
VkDeviceSize rowPitch;
VkDeviceSize arrayPitch;
VkDeviceSize depthPitch;
} VkSubresourceLayout;
typedef struct {
VkComponentSwizzle r;
VkComponentSwizzle g;
VkComponentSwizzle b;
VkComponentSwizzle a;
} VkComponentMapping;
typedef struct {
VkImageAspectFlags aspectMask;
uint32_t baseMipLevel;
uint32_t levelCount;
uint32_t baseArrayLayer;
uint32_t layerCount;
} VkImageSubresourceRange;
typedef struct {
VkStructureType sType;
void* pNext;
VkImageViewCreateFlags flags;
VkImage image;
VkImageViewType viewType;
VkFormat format;
VkComponentMapping components;
VkImageSubresourceRange subresourceRange;
} VkImageViewCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkShaderModuleCreateFlags flags;
size_val codeSize;
uint32_t* pCode;
} VkShaderModuleCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineCacheCreateFlags flags;
size_val initialDataSize;
void* pInitialData;
} VkPipelineCacheCreateInfo;
typedef struct {
uint32_t constantID;
uint32_t offset;
size_val size;
} VkSpecializationMapEntry;
typedef struct {
uint32_t mapEntryCount;
VkSpecializationMapEntry* pMapEntries;
size_val dataSize;
void* pData;
} VkSpecializationInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineShaderStageCreateFlags flags;
VkShaderStageFlagBits stage;
VkShaderModule module;
char* pName;
VkSpecializationInfo* pSpecializationInfo;
} VkPipelineShaderStageCreateInfo;
typedef struct {
uint32_t binding;
uint32_t stride;
VkVertexInputRate inputRate;
} VkVertexInputBindingDescription;
typedef struct {
uint32_t location;
uint32_t binding;
VkFormat format;
uint32_t offset;
} VkVertexInputAttributeDescription;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineVertexInputStateCreateFlags flags;
uint32_t vertexBindingDescriptionCount;
VkVertexInputBindingDescription* pVertexBindingDescriptions;
uint32_t vertexAttributeDescriptionCount;
VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
} VkPipelineVertexInputStateCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineInputAssemblyStateCreateFlags flags;
VkPrimitiveTopology topology;
VkBool32 primitiveRestartEnable;
} VkPipelineInputAssemblyStateCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineTessellationStateCreateFlags flags;
uint32_t patchControlPoints;
} VkPipelineTessellationStateCreateInfo;
typedef struct {
float x;
float y;
float width;
float height;
float minDepth;
float maxDepth;
} VkViewport;
typedef struct {
int32_t x;
int32_t y;
} VkOffset2D;
typedef struct {
uint32_t width;
uint32_t height;
} VkExtent2D;
typedef struct {
VkOffset2D offset;
VkExtent2D extent;
} VkRect2D;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineViewportStateCreateFlags flags;
uint32_t viewportCount;
VkViewport* pViewports;
uint32_t scissorCount;
VkRect2D* pScissors;
} VkPipelineViewportStateCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineRasterizationStateCreateFlags flags;
VkBool32 depthClampEnable;
VkBool32 rasterizerDiscardEnable;
VkPolygonMode polygonMode;
VkCullModeFlags cullMode;
VkFrontFace frontFace;
VkBool32 depthBiasEnable;
float depthBiasConstantFactor;
float depthBiasClamp;
float depthBiasSlopeFactor;
float lineWidth;
} VkPipelineRasterizationStateCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineMultisampleStateCreateFlags flags;
VkSampleCountFlagBits rasterizationSamples;
VkBool32 sampleShadingEnable;
float minSampleShading;
VkSampleMask* pSampleMask;
VkBool32 alphaToCoverageEnable;
VkBool32 alphaToOneEnable;
} VkPipelineMultisampleStateCreateInfo;
typedef struct {
VkStencilOp failOp;
VkStencilOp passOp;
VkStencilOp depthFailOp;
VkCompareOp compareOp;
uint32_t compareMask;
uint32_t writeMask;
uint32_t reference;
} VkStencilOpState;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineDepthStencilStateCreateFlags flags;
VkBool32 depthTestEnable;
VkBool32 depthWriteEnable;
VkCompareOp depthCompareOp;
VkBool32 depthBoundsTestEnable;
VkBool32 stencilTestEnable;
VkStencilOpState front;
VkStencilOpState back;
float minDepthBounds;
float maxDepthBounds;
} VkPipelineDepthStencilStateCreateInfo;
typedef struct {
VkBool32 blendEnable;
VkBlendFactor srcColorBlendFactor;
VkBlendFactor dstColorBlendFactor;
VkBlendOp colorBlendOp;
VkBlendFactor srcAlphaBlendFactor;
VkBlendFactor dstAlphaBlendFactor;
VkBlendOp alphaBlendOp;
VkColorComponentFlags colorWriteMask;
} VkPipelineColorBlendAttachmentState;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineColorBlendStateCreateFlags flags;
VkBool32 logicOpEnable;
VkLogicOp logicOp;
uint32_t attachmentCount;
VkPipelineColorBlendAttachmentState* pAttachments;
gapic::StaticArray<float, 4> blendConstants;
} VkPipelineColorBlendStateCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineDynamicStateCreateFlags flags;
uint32_t dynamicStateCount;
VkDynamicState* pDynamicStates;
} VkPipelineDynamicStateCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineCreateFlags flags;
uint32_t stageCount;
VkPipelineShaderStageCreateInfo* pStages;
VkPipelineVertexInputStateCreateInfo* pVertexInputState;
VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
VkPipelineTessellationStateCreateInfo* pTessellationState;
VkPipelineViewportStateCreateInfo* pViewportState;
VkPipelineRasterizationStateCreateInfo* pRasterizationState;
VkPipelineMultisampleStateCreateInfo* pMultisampleState;
VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
VkPipelineColorBlendStateCreateInfo* pColorBlendState;
VkPipelineDynamicStateCreateInfo* pDynamicState;
VkPipelineLayout layout;
VkRenderPass renderPass;
uint32_t subpass;
VkPipeline basePipelineHandle;
int32_t basePipelineIndex;
} VkGraphicsPipelineCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineCreateFlags flags;
VkPipelineShaderStageCreateInfo stage;
VkPipelineLayout layout;
VkPipeline basePipelineHandle;
int32_t basePipelineIndex;
} VkComputePipelineCreateInfo;
typedef struct {
VkShaderStageFlags stageFlags;
uint32_t offset;
uint32_t size;
} VkPushConstantRange;
typedef struct {
VkStructureType sType;
void* pNext;
VkPipelineLayoutCreateFlags flags;
uint32_t setLayoutCount;
VkDescriptorSetLayout* pSetLayouts;
uint32_t pushConstantRangeCount;
VkPushConstantRange* pPushConstantRanges;
} VkPipelineLayoutCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkSamplerCreateFlags flags;
VkFilter magFilter;
VkFilter minFilter;
VkSamplerMipmapMode mipmapMode;
VkSamplerAddressMode addressModeU;
VkSamplerAddressMode addressModeV;
VkSamplerAddressMode addressModeW;
float mipLodBias;
VkBool32 anisotropyEnable;
float maxAnisotropy;
VkBool32 compareEnable;
VkCompareOp compareOp;
float minLod;
float maxLod;
VkBorderColor borderColor;
VkBool32 unnormalizedCoordinates;
} VkSamplerCreateInfo;
typedef struct {
uint32_t binding;
VkDescriptorType descriptorType;
uint32_t descriptorCount;
VkShaderStageFlags stageFlags;
VkSampler* pImmutableSamplers;
} VkDescriptorSetLayoutBinding;
typedef struct {
VkStructureType sType;
void* pNext;
VkDescriptorSetLayoutCreateFlags flags;
uint32_t bindingCount;
VkDescriptorSetLayoutBinding* pBindings;
} VkDescriptorSetLayoutCreateInfo;
typedef struct {
VkDescriptorType type;
uint32_t descriptorCount;
} VkDescriptorPoolSize;
typedef struct {
VkStructureType sType;
void* pNext;
VkDescriptorPoolCreateFlags flags;
uint32_t maxSets;
uint32_t poolSizeCount;
VkDescriptorPoolSize* pPoolSizes;
} VkDescriptorPoolCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkDescriptorPool descriptorPool;
uint32_t descriptorSetCount;
VkDescriptorSetLayout* pSetLayouts;
} VkDescriptorSetAllocateInfo;
typedef struct {
VkSampler sampler;
VkImageView imageView;
VkImageLayout imageLayout;
} VkDescriptorImageInfo;
typedef struct {
VkBuffer buffer;
VkDeviceSize offset;
VkDeviceSize range;
} VkDescriptorBufferInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkDescriptorSet dstSet;
uint32_t dstBinding;
uint32_t dstArrayElement;
uint32_t descriptorCount;
VkDescriptorType descriptorType;
VkDescriptorImageInfo* pImageInfo;
VkDescriptorBufferInfo* pBufferInfo;
VkBufferView* pTexelBufferView;
} VkWriteDescriptorSet;
typedef struct {
VkStructureType sType;
void* pNext;
VkDescriptorSet srcSet;
uint32_t srcBinding;
uint32_t srcArrayElement;
VkDescriptorSet dstSet;
uint32_t dstBinding;
uint32_t dstArrayElement;
uint32_t descriptorCount;
} VkCopyDescriptorSet;
typedef struct {
VkStructureType sType;
void* pNext;
VkFramebufferCreateFlags flags;
VkRenderPass renderPass;
uint32_t attachmentCount;
VkImageView* pAttachments;
uint32_t width;
uint32_t height;
uint32_t layers;
} VkFramebufferCreateInfo;
typedef struct {
VkAttachmentDescriptionFlags flags;
VkFormat format;
VkSampleCountFlagBits samples;
VkAttachmentLoadOp loadOp;
VkAttachmentStoreOp storeOp;
VkAttachmentLoadOp stencilLoadOp;
VkAttachmentStoreOp stencilStoreOp;
VkImageLayout initialLayout;
VkImageLayout finalLayout;
} VkAttachmentDescription;
typedef struct {
uint32_t attachment;
VkImageLayout layout;
} VkAttachmentReference;
typedef struct {
VkSubpassDescriptionFlags flags;
VkPipelineBindPoint pipelineBindPoint;
uint32_t inputAttachmentCount;
VkAttachmentReference* pInputAttachments;
uint32_t colorAttachmentCount;
VkAttachmentReference* pColorAttachments;
VkAttachmentReference* pResolveAttachments;
VkAttachmentReference* pDepthStencilAttachment;
uint32_t preserveAttachmentCount;
uint32_t* pPreserveAttachments;
} VkSubpassDescription;
typedef struct {
uint32_t srcSubpass;
uint32_t dstSubpass;
VkPipelineStageFlags srcStageMask;
VkPipelineStageFlags dstStageMask;
VkAccessFlags srcAccessMask;
VkAccessFlags dstAccessMask;
VkDependencyFlags dependencyFlags;
} VkSubpassDependency;
typedef struct {
VkStructureType sType;
void* pNext;
VkRenderPassCreateFlags flags;
uint32_t attachmentCount;
VkAttachmentDescription* pAttachments;
uint32_t subpassCount;
VkSubpassDescription* pSubpasses;
uint32_t dependencyCount;
VkSubpassDependency* pDependencies;
} VkRenderPassCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkCommandPoolCreateFlags flags;
uint32_t queueFamilyIndex;
} VkCommandPoolCreateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkCommandPool commandPool;
VkCommandBufferLevel level;
uint32_t commandBufferCount;
} VkCommandBufferAllocateInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkRenderPass renderPass;
uint32_t subpass;
VkFramebuffer framebuffer;
VkBool32 occlusionQueryEnable;
VkQueryControlFlags queryFlags;
VkQueryPipelineStatisticFlags pipelineStatistics;
} VkCommandBufferInheritanceInfo;
typedef struct {
VkStructureType sType;
void* pNext;
VkCommandBufferUsageFlags flags;
VkCommandBufferInheritanceInfo* pInheritanceInfo;
} VkCommandBufferBeginInfo;
typedef struct {
VkDeviceSize srcOffset;
VkDeviceSize dstOffset;
VkDeviceSize size;
} VkBufferCopy;
typedef struct {
VkImageAspectFlags aspectMask;
uint32_t mipLevel;
uint32_t baseArrayLayer;
uint32_t layerCount;
} VkImageSubresourceLayers;
typedef struct {
VkImageSubresourceLayers srcSubresource;
VkOffset3D srcOffset;
VkImageSubresourceLayers dstSubresource;
VkOffset3D dstOffset;
VkExtent3D extent;
} VkImageCopy;
typedef struct {
VkImageSubresourceLayers srcSubresource;
gapic::StaticArray<VkOffset3D, 2> srcOffsets;
VkImageSubresourceLayers dstSubresource;
gapic::StaticArray<VkOffset3D, 2> dstOffsets;
} VkImageBlit;
typedef struct {
VkDeviceSize bufferOffset;
uint32_t bufferRowLength;
uint32_t bufferImageHeight;
VkImageSubresourceLayers imageSubresource;
VkOffset3D imageOffset;
VkExtent3D imageExtent;
} VkBufferImageCopy;
typedef struct {
gapic::StaticArray<uint32_t, 4> uint32;
} VkClearColorValue;
typedef struct {
float depth;
uint32_t stencil;
} VkClearDepthStencilValue;
typedef struct {
VkClearColorValue color;
} VkClearValue;
typedef struct {
VkImageAspectFlags aspectMask;
uint32_t colorAttachment;
VkClearValue clearValue;
} VkClearAttachment;
typedef struct {
VkRect2D rect;
uint32_t baseArrayLayer;
uint32_t layerCount;
} VkClearRect;
typedef struct {
VkImageSubresourceLayers srcSubresource;
VkOffset3D srcOffset;
VkImageSubresourceLayers dstSubresource;
VkOffset3D dstOffset;
VkExtent3D extent;
} VkImageResolve;
typedef struct {
VkStructureType sType;
void* pNext;
VkAccessFlags srcAccessMask;
VkAccessFlags dstAccessMask;
} VkMemoryBarrier;
typedef struct {
VkStructureType sType;
void* pNext;
VkAccessFlags srcAccessMask;
VkAccessFlags dstAccessMask;
uint32_t srcQueueFamilyIndex;
uint32_t dstQueueFamilyIndex;
VkBuffer buffer;
VkDeviceSize offset;
VkDeviceSize size;
} VkBufferMemoryBarrier;
typedef struct {
VkStructureType sType;
void* pNext;
VkAccessFlags srcAccessMask;
VkAccessFlags dstAccessMask;
VkImageLayout oldLayout;
VkImageLayout newLayout;
uint32_t srcQueueFamilyIndex;
uint32_t dstQueueFamilyIndex;
VkImage image;
VkImageSubresourceRange subresourceRange;
} VkImageMemoryBarrier;
typedef struct {
VkStructureType sType;
void* pNext;
VkRenderPass renderPass;
VkFramebuffer framebuffer;
VkRect2D renderArea;
uint32_t clearValueCount;
VkClearValue* pClearValues;
} VkRenderPassBeginInfo;
typedef struct {
uint32_t x;
uint32_t y;
uint32_t z;
} VkDispatchIndirectCommand;
typedef struct {
uint32_t indexCount;
uint32_t instanceCount;
uint32_t firstIndex;
int32_t vertexOffset;
uint32_t firstInstance;
} VkDrawIndexedIndirectCommand;
typedef struct {
uint32_t vertexCount;
uint32_t instanceCount;
uint32_t firstVertex;
uint32_t firstInstance;
} VkDrawIndirectCommand;
typedef struct {
VkStructureType sType;
void* pNext;
VkBool32 dedicatedAllocation;
} VkDedicatedAllocationImageCreateInfoNV;
typedef struct {
VkStructureType sType;
void* pNext;
VkBool32 dedicatedAllocation;
} VkDedicatedAllocationBufferCreateInfoNV;
typedef struct {
VkStructureType sType;
void* pNext;
VkImage image;
VkBuffer buffer;
} VkDedicatedAllocationMemoryAllocateInfoNV;
typedef struct {
VkPipelineBindPoint PipelineBindPoint;
VkPipeline Pipeline;
} CmdBindPipeline;
typedef struct {
VkFramebuffer Framebuffer;
} CmdBeginRenderPass;
typedef struct {
uint32_t minImageCount;
uint32_t maxImageCount;
VkExtent2D currentExtent;
VkExtent2D minImageExtent;
VkExtent2D maxImageExtent;
uint32_t maxImageArrayLayers;
VkSurfaceTransformFlagsKHR supportedTransforms;
VkSurfaceTransformFlagBitsKHR currentTransform;
VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
VkImageUsageFlags supportedUsageFlags;
} VkSurfaceCapabilitiesKHR;
typedef struct {
VkFormat format;
VkColorSpaceKHR colorSpace;
} VkSurfaceFormatKHR;
typedef struct {
VkStructureType sType;
void* pNext;
VkSwapchainCreateFlagsKHR flags;
VkSurfaceKHR surface;
uint32_t minImageCount;
VkFormat imageFormat;
VkColorSpaceKHR imageColorSpace;
VkExtent2D imageExtent;
uint32_t imageArrayLayers;
VkImageUsageFlags imageUsage;
VkSharingMode imageSharingMode;
uint32_t queueFamilyIndexCount;
uint32_t* pQueueFamilyIndices;
VkSurfaceTransformFlagBitsKHR preTransform;
VkCompositeAlphaFlagBitsKHR compositeAlpha;
VkPresentModeKHR presentMode;
VkBool32 clipped;
VkSwapchainKHR oldSwapchain;
} VkSwapchainCreateInfoKHR;
typedef struct {
VkStructureType sType;
void* pNext;
uint32_t waitSemaphoreCount;
VkSemaphore* pWaitSemaphores;
uint32_t swapchainCount;
VkSwapchainKHR* pSwapchains;
uint32_t* pImageIndices;
VkResult* pResults;
} VkPresentInfoKHR;
typedef struct {
VkDisplayKHR display;
std::string displayName;
VkExtent2D physicalDimensions;
VkExtent2D physicalResolution;
VkSurfaceTransformFlagsKHR supportedTransforms;
VkBool32 planeReorderPossible;
VkBool32 persistentContent;
} VkDisplayPropertiesKHR;
typedef struct {
VkExtent2D visibleRegion;
uint32_t refreshRate;
} VkDisplayModeParametersKHR;
typedef struct {
VkDisplayModeKHR displayMode;
VkDisplayModeParametersKHR parameters;
} VkDisplayModePropertiesKHR;
typedef struct {
VkStructureType sType;
void* pNext;
VkDisplayModeCreateFlagsKHR flags;
VkDisplayModeParametersKHR parameters;
} VkDisplayModeCreateInfoKHR;
typedef struct {
VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
VkOffset2D minSrcPosition;
VkOffset2D maxSrcPosition;
VkExtent2D minSrcExtent;
VkExtent2D maxSrcExtent;
VkOffset2D minDstPosition;
VkOffset2D maxDstPosition;
VkExtent2D minDstExtent;
VkExtent2D maxDstExtent;
} VkDisplayPlaneCapabilitiesKHR;
typedef struct {
VkDisplayKHR currentDisplay;
uint32_t currentStackIndex;
} VkDisplayPlanePropertiesKHR;
typedef struct {
VkStructureType sType;
void* pNext;
VkDisplaySurfaceCreateFlagsKHR flags;
VkDisplayModeKHR displayMode;
uint32_t planeIndex;
uint32_t planeStackIndex;
VkSurfaceTransformFlagBitsKHR transform;
float globalAlpha;
VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
VkExtent2D imageExtent;
} VkDisplaySurfaceCreateInfoKHR;
typedef struct {
VkStructureType sType;
void* pNext;
VkRect2D srcRect;
VkRect2D dstRect;
VkBool32 persistent;
} VkDisplayPresentInfoKHR;
typedef struct {
VkStructureType sType;
void* pNext;
VkDebugReportFlagsEXT flags;
PFN_vkDebugReportCallbackEXT pfnCallback;
void* pUserData;
} VkDebugReportCallbackCreateInfoEXT;
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEANDROIDSURFACEKHR)(VkInstance instance, VkAndroidSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkResult (VULKAN_API_PTR *PFNVKGETSWAPCHAINGRALLOCUSAGEANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
typedef VkResult (VULKAN_API_PTR *PFNVKACQUIREIMAGEANDROID)(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
typedef VkResult (VULKAN_API_PTR *PFNVKQUEUESIGNALRELEASEIMAGEANDROID)(VkQueue queue, uint32_t waitSemaphoreCount, VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEXLIBSURFACEKHR)(VkInstance instance, VkXlibSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEXLIBPRESENTATIONSUPPORTKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEXCBSURFACEKHR)(VkInstance instance, VkXcbSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEXCBPRESENTATIONSUPPORTKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEWAYLANDSURFACEKHR)(VkInstance instance, VkWaylandSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEWAYLANDPRESENTATIONSUPPORTKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, wl_display* display);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEMIRSURFACEKHR)(VkInstance instance, VkMirSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEMIRPRESENTATIONSUPPORTKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
typedef void* (VULKAN_API_PTR *PFNVKALLOCATIONFUNCTION)(void* pUserData, size_val size, size_val alignment, VkSystemAllocationScope allocationScope);
typedef void* (VULKAN_API_PTR *PFNVKREALLOCATIONFUNCTION)(void* pUserData, void* pOriginal, size_val size, size_val alignment, VkSystemAllocationScope allocationScope);
typedef void (VULKAN_API_PTR *PFNVKFREEFUNCTION)(void* pUserData, void* pMemory);
typedef void (VULKAN_API_PTR *PFNVKINTERNALALLOCATIONNOTIFICATION)(void* pUserData, size_val size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope);
typedef void (VULKAN_API_PTR *PFNVKINTERNALFREENOTIFICATION)(void* pUserData, size_val size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope);
typedef void (VULKAN_API_PTR *PFNVKVOIDFUNCTION)();
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEINSTANCE)(VkInstanceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
typedef void (VULKAN_API_PTR *PFNVKDESTROYINSTANCE)(VkInstance instance, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKENUMERATEPHYSICALDEVICES)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEFEATURES)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEFORMATPROPERTIES)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEIMAGEFORMATPROPERTIES)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEPROPERTIES)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEQUEUEFAMILYPROPERTIES)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEMEMORYPROPERTIES)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
typedef PFN_vkVoidFunction (VULKAN_API_PTR *PFNVKGETINSTANCEPROCADDR)(VkInstance instance, const char* pName);
typedef PFN_vkVoidFunction (VULKAN_API_PTR *PFNVKGETDEVICEPROCADDR)(VkDevice device, const char* pName);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDEVICE)(VkPhysicalDevice physicalDevice, VkDeviceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
typedef void (VULKAN_API_PTR *PFNVKDESTROYDEVICE)(VkDevice device, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKENUMERATEINSTANCEEXTENSIONPROPERTIES)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
typedef VkResult (VULKAN_API_PTR *PFNVKENUMERATEDEVICEEXTENSIONPROPERTIES)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
typedef VkResult (VULKAN_API_PTR *PFNVKENUMERATEINSTANCELAYERPROPERTIES)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
typedef VkResult (VULKAN_API_PTR *PFNVKENUMERATEDEVICELAYERPROPERTIES)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
typedef void (VULKAN_API_PTR *PFNVKGETDEVICEQUEUE)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
typedef VkResult (VULKAN_API_PTR *PFNVKQUEUESUBMIT)(VkQueue queue, uint32_t submitCount, VkSubmitInfo* pSubmits, VkFence fence);
typedef VkResult (VULKAN_API_PTR *PFNVKQUEUEWAITIDLE)(VkQueue queue);
typedef VkResult (VULKAN_API_PTR *PFNVKDEVICEWAITIDLE)(VkDevice device);
typedef VkResult (VULKAN_API_PTR *PFNVKALLOCATEMEMORY)(VkDevice device, VkMemoryAllocateInfo* pAllocateInfo, VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
typedef void (VULKAN_API_PTR *PFNVKFREEMEMORY)(VkDevice device, VkDeviceMemory memory, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKMAPMEMORY)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
typedef void (VULKAN_API_PTR *PFNVKUNMAPMEMORY)(VkDevice device, VkDeviceMemory memory);
typedef VkResult (VULKAN_API_PTR *PFNVKFLUSHMAPPEDMEMORYRANGES)(VkDevice device, uint32_t memoryRangeCount, VkMappedMemoryRange* pMemoryRanges);
typedef VkResult (VULKAN_API_PTR *PFNVKINVALIDATEMAPPEDMEMORYRANGES)(VkDevice device, uint32_t memoryRangeCount, VkMappedMemoryRange* pMemoryRanges);
typedef void (VULKAN_API_PTR *PFNVKGETDEVICEMEMORYCOMMITMENT)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
typedef VkResult (VULKAN_API_PTR *PFNVKBINDBUFFERMEMORY)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
typedef VkResult (VULKAN_API_PTR *PFNVKBINDIMAGEMEMORY)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
typedef void (VULKAN_API_PTR *PFNVKGETBUFFERMEMORYREQUIREMENTS)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
typedef void (VULKAN_API_PTR *PFNVKGETIMAGEMEMORYREQUIREMENTS)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
typedef void (VULKAN_API_PTR *PFNVKGETIMAGESPARSEMEMORYREQUIREMENTS)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICESPARSEIMAGEFORMATPROPERTIES)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
typedef VkResult (VULKAN_API_PTR *PFNVKQUEUEBINDSPARSE)(VkQueue queue, uint32_t bindInfoCount, VkBindSparseInfo* pBindInfo, VkFence fence);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEFENCE)(VkDevice device, VkFenceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkFence* pFence);
typedef void (VULKAN_API_PTR *PFNVKDESTROYFENCE)(VkDevice device, VkFence fence, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKRESETFENCES)(VkDevice device, uint32_t fenceCount, VkFence* pFences);
typedef VkResult (VULKAN_API_PTR *PFNVKGETFENCESTATUS)(VkDevice device, VkFence fence);
typedef VkResult (VULKAN_API_PTR *PFNVKWAITFORFENCES)(VkDevice device, uint32_t fenceCount, VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATESEMAPHORE)(VkDevice device, VkSemaphoreCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
typedef void (VULKAN_API_PTR *PFNVKDESTROYSEMAPHORE)(VkDevice device, VkSemaphore semaphore, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEEVENT)(VkDevice device, VkEventCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
typedef void (VULKAN_API_PTR *PFNVKDESTROYEVENT)(VkDevice device, VkEvent event, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKGETEVENTSTATUS)(VkDevice device, VkEvent event);
typedef VkResult (VULKAN_API_PTR *PFNVKSETEVENT)(VkDevice device, VkEvent event);
typedef VkResult (VULKAN_API_PTR *PFNVKRESETEVENT)(VkDevice device, VkEvent event);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEQUERYPOOL)(VkDevice device, VkQueryPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
typedef void (VULKAN_API_PTR *PFNVKDESTROYQUERYPOOL)(VkDevice device, VkQueryPool queryPool, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKGETQUERYPOOLRESULTS)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_val dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEBUFFER)(VkDevice device, VkBufferCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
typedef void (VULKAN_API_PTR *PFNVKDESTROYBUFFER)(VkDevice device, VkBuffer buffer, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEBUFFERVIEW)(VkDevice device, VkBufferViewCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkBufferView* pView);
typedef void (VULKAN_API_PTR *PFNVKDESTROYBUFFERVIEW)(VkDevice device, VkBufferView bufferView, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEIMAGE)(VkDevice device, VkImageCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkImage* pImage);
typedef void (VULKAN_API_PTR *PFNVKDESTROYIMAGE)(VkDevice device, VkImage image, VkAllocationCallbacks* pAllocator);
typedef void (VULKAN_API_PTR *PFNVKGETIMAGESUBRESOURCELAYOUT)(VkDevice device, VkImage image, VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEIMAGEVIEW)(VkDevice device, VkImageViewCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkImageView* pView);
typedef void (VULKAN_API_PTR *PFNVKDESTROYIMAGEVIEW)(VkDevice device, VkImageView imageView, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATESHADERMODULE)(VkDevice device, VkShaderModuleCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
typedef void (VULKAN_API_PTR *PFNVKDESTROYSHADERMODULE)(VkDevice device, VkShaderModule shaderModule, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEPIPELINECACHE)(VkDevice device, VkPipelineCacheCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
typedef void (VULKAN_API_PTR *PFNVKDESTROYPIPELINECACHE)(VkDevice device, VkPipelineCache pipelineCache, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKGETPIPELINECACHEDATA)(VkDevice device, VkPipelineCache pipelineCache, size_val* pDataSize, void* pData);
typedef VkResult (VULKAN_API_PTR *PFNVKMERGEPIPELINECACHES)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, VkPipelineCache* pSrcCaches);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEGRAPHICSPIPELINES)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, VkGraphicsPipelineCreateInfo* pCreateInfos, VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATECOMPUTEPIPELINES)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, VkComputePipelineCreateInfo* pCreateInfos, VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
typedef void (VULKAN_API_PTR *PFNVKDESTROYPIPELINE)(VkDevice device, VkPipeline pipeline, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEPIPELINELAYOUT)(VkDevice device, VkPipelineLayoutCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
typedef void (VULKAN_API_PTR *PFNVKDESTROYPIPELINELAYOUT)(VkDevice device, VkPipelineLayout pipelineLayout, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATESAMPLER)(VkDevice device, VkSamplerCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
typedef void (VULKAN_API_PTR *PFNVKDESTROYSAMPLER)(VkDevice device, VkSampler sampler, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDESCRIPTORSETLAYOUT)(VkDevice device, VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
typedef void (VULKAN_API_PTR *PFNVKDESTROYDESCRIPTORSETLAYOUT)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDESCRIPTORPOOL)(VkDevice device, VkDescriptorPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
typedef void (VULKAN_API_PTR *PFNVKDESTROYDESCRIPTORPOOL)(VkDevice device, VkDescriptorPool descriptorPool, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKRESETDESCRIPTORPOOL)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
typedef VkResult (VULKAN_API_PTR *PFNVKALLOCATEDESCRIPTORSETS)(VkDevice device, VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
typedef VkResult (VULKAN_API_PTR *PFNVKFREEDESCRIPTORSETS)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, VkDescriptorSet* pDescriptorSets);
typedef void (VULKAN_API_PTR *PFNVKUPDATEDESCRIPTORSETS)(VkDevice device, uint32_t descriptorWriteCount, VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, VkCopyDescriptorSet* pDescriptorCopies);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEFRAMEBUFFER)(VkDevice device, VkFramebufferCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
typedef void (VULKAN_API_PTR *PFNVKDESTROYFRAMEBUFFER)(VkDevice device, VkFramebuffer framebuffer, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATERENDERPASS)(VkDevice device, VkRenderPassCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
typedef void (VULKAN_API_PTR *PFNVKDESTROYRENDERPASS)(VkDevice device, VkRenderPass renderPass, VkAllocationCallbacks* pAllocator);
typedef void (VULKAN_API_PTR *PFNVKGETRENDERAREAGRANULARITY)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATECOMMANDPOOL)(VkDevice device, VkCommandPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
typedef void (VULKAN_API_PTR *PFNVKDESTROYCOMMANDPOOL)(VkDevice device, VkCommandPool commandPool, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKRESETCOMMANDPOOL)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
typedef VkResult (VULKAN_API_PTR *PFNVKALLOCATECOMMANDBUFFERS)(VkDevice device, VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
typedef void (VULKAN_API_PTR *PFNVKFREECOMMANDBUFFERS)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, VkCommandBuffer* pCommandBuffers);
typedef VkResult (VULKAN_API_PTR *PFNVKBEGINCOMMANDBUFFER)(VkCommandBuffer commandBuffer, VkCommandBufferBeginInfo* pBeginInfo);
typedef VkResult (VULKAN_API_PTR *PFNVKENDCOMMANDBUFFER)(VkCommandBuffer commandBuffer);
typedef VkResult (VULKAN_API_PTR *PFNVKRESETCOMMANDBUFFER)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
typedef void (VULKAN_API_PTR *PFNVKCMDBINDPIPELINE)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
typedef void (VULKAN_API_PTR *PFNVKCMDSETVIEWPORT)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, VkViewport* pViewports);
typedef void (VULKAN_API_PTR *PFNVKCMDSETSCISSOR)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, VkRect2D* pScissors);
typedef void (VULKAN_API_PTR *PFNVKCMDSETLINEWIDTH)(VkCommandBuffer commandBuffer, float lineWidth);
typedef void (VULKAN_API_PTR *PFNVKCMDSETDEPTHBIAS)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
typedef void (VULKAN_API_PTR *PFNVKCMDSETBLENDCONSTANTS)(VkCommandBuffer commandBuffer, float blendConstants[4]);
typedef void (VULKAN_API_PTR *PFNVKCMDSETDEPTHBOUNDS)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
typedef void (VULKAN_API_PTR *PFNVKCMDSETSTENCILCOMPAREMASK)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
typedef void (VULKAN_API_PTR *PFNVKCMDSETSTENCILWRITEMASK)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
typedef void (VULKAN_API_PTR *PFNVKCMDSETSTENCILREFERENCE)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
typedef void (VULKAN_API_PTR *PFNVKCMDBINDDESCRIPTORSETS)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, uint32_t* pDynamicOffsets);
typedef void (VULKAN_API_PTR *PFNVKCMDBINDINDEXBUFFER)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
typedef void (VULKAN_API_PTR *PFNVKCMDBINDVERTEXBUFFERS)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, VkBuffer* pBuffers, VkDeviceSize* pOffsets);
typedef void (VULKAN_API_PTR *PFNVKCMDDRAW)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
typedef void (VULKAN_API_PTR *PFNVKCMDDRAWINDEXED)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
typedef void (VULKAN_API_PTR *PFNVKCMDDRAWINDIRECT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
typedef void (VULKAN_API_PTR *PFNVKCMDDRAWINDEXEDINDIRECT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
typedef void (VULKAN_API_PTR *PFNVKCMDDISPATCH)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
typedef void (VULKAN_API_PTR *PFNVKCMDDISPATCHINDIRECT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
typedef void (VULKAN_API_PTR *PFNVKCMDCOPYBUFFER)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, VkBufferCopy* pRegions);
typedef void (VULKAN_API_PTR *PFNVKCMDCOPYIMAGE)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkImageCopy* pRegions);
typedef void (VULKAN_API_PTR *PFNVKCMDBLITIMAGE)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkImageBlit* pRegions, VkFilter filter);
typedef void (VULKAN_API_PTR *PFNVKCMDCOPYBUFFERTOIMAGE)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkBufferImageCopy* pRegions);
typedef void (VULKAN_API_PTR *PFNVKCMDCOPYIMAGETOBUFFER)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, VkBufferImageCopy* pRegions);
typedef void (VULKAN_API_PTR *PFNVKCMDUPDATEBUFFER)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, void* pData);
typedef void (VULKAN_API_PTR *PFNVKCMDFILLBUFFER)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
typedef void (VULKAN_API_PTR *PFNVKCMDCLEARCOLORIMAGE)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearColorValue* pColor, uint32_t rangeCount, VkImageSubresourceRange* pRanges);
typedef void (VULKAN_API_PTR *PFNVKCMDCLEARDEPTHSTENCILIMAGE)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, VkImageSubresourceRange* pRanges);
typedef void (VULKAN_API_PTR *PFNVKCMDCLEARATTACHMENTS)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, VkClearAttachment* pAttachments, uint32_t rectCount, VkClearRect* pRects);
typedef void (VULKAN_API_PTR *PFNVKCMDRESOLVEIMAGE)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkImageResolve* pRegions);
typedef void (VULKAN_API_PTR *PFNVKCMDSETEVENT)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
typedef void (VULKAN_API_PTR *PFNVKCMDRESETEVENT)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
typedef void (VULKAN_API_PTR *PFNVKCMDWAITEVENTS)(VkCommandBuffer commandBuffer, uint32_t eventCount, VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, VkImageMemoryBarrier* pImageMemoryBarriers);
typedef void (VULKAN_API_PTR *PFNVKCMDPIPELINEBARRIER)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, VkImageMemoryBarrier* pImageMemoryBarriers);
typedef void (VULKAN_API_PTR *PFNVKCMDBEGINQUERY)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
typedef void (VULKAN_API_PTR *PFNVKCMDENDQUERY)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
typedef void (VULKAN_API_PTR *PFNVKCMDRESETQUERYPOOL)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
typedef void (VULKAN_API_PTR *PFNVKCMDWRITETIMESTAMP)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
typedef void (VULKAN_API_PTR *PFNVKCMDCOPYQUERYPOOLRESULTS)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
typedef void (VULKAN_API_PTR *PFNVKCMDPUSHCONSTANTS)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, void* pValues);
typedef void (VULKAN_API_PTR *PFNVKCMDBEGINRENDERPASS)(VkCommandBuffer commandBuffer, VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
typedef void (VULKAN_API_PTR *PFNVKCMDNEXTSUBPASS)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
typedef void (VULKAN_API_PTR *PFNVKCMDENDRENDERPASS)(VkCommandBuffer commandBuffer);
typedef void (VULKAN_API_PTR *PFNVKCMDEXECUTECOMMANDS)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, VkCommandBuffer* pCommandBuffers);
typedef void (VULKAN_API_PTR *PFNVKDESTROYSURFACEKHR)(VkInstance instance, VkSurfaceKHR surface, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICESURFACESUPPORTKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICESURFACECAPABILITIESKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICESURFACEFORMATSKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICESURFACEPRESENTMODESKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATESWAPCHAINKHR)(VkDevice device, VkSwapchainCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
typedef void (VULKAN_API_PTR *PFNVKDESTROYSWAPCHAINKHR)(VkDevice device, VkSwapchainKHR swapchain, VkAllocationCallbacks* pAllocator);
typedef VkResult (VULKAN_API_PTR *PFNVKGETSWAPCHAINIMAGESKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
typedef VkResult (VULKAN_API_PTR *PFNVKACQUIRENEXTIMAGEKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
typedef VkResult (VULKAN_API_PTR *PFNVKQUEUEPRESENTKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo);
typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEDISPLAYPROPERTIESKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEDISPLAYPLANEPROPERTIESKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
typedef VkResult (VULKAN_API_PTR *PFNVKGETDISPLAYPLANESUPPORTEDDISPLAYSKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
typedef VkResult (VULKAN_API_PTR *PFNVKGETDISPLAYMODEPROPERTIESKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDISPLAYMODEKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkDisplayModeCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
typedef VkResult (VULKAN_API_PTR *PFNVKGETDISPLAYPLANECAPABILITIESKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDISPLAYPLANESURFACEKHR)(VkInstance instance, VkDisplaySurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATESHAREDSWAPCHAINSKHR)(VkDevice device, uint32_t swapchainCount, VkSwapchainCreateInfoKHR* pCreateInfos, VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
typedef VkBool32 (VULKAN_API_PTR *PFNVKDEBUGREPORTCALLBACKEXT)(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_val location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData);
typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDEBUGREPORTCALLBACKEXT)(VkInstance instance, VkDebugReportCallbackCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
typedef void (VULKAN_API_PTR *PFNVKDESTROYDEBUGREPORTCALLBACKEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, VkAllocationCallbacks* pAllocator);
typedef void (VULKAN_API_PTR *PFNVKDEBUGREPORTMESSAGEEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_val location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);
struct VkInstanceFunctionStubs {
PFNVKCREATEANDROIDSURFACEKHR vkCreateAndroidSurfaceKHR = nullptr;
PFNVKCREATEXLIBSURFACEKHR vkCreateXlibSurfaceKHR = nullptr