From a158ff55f09afbff5c35d07289e299192f17dc3f Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 13 Jul 2015 11:46:30 -0700 Subject: [PATCH] vk/vulkan.h: Remove headers for old API versions Remove the temporary headers for 0.90 and 0.130. --- include/vulkan/vulkan-130.h | 2753 --------------------------------- include/vulkan/vulkan-90.h | 2894 ----------------------------------- 2 files changed, 5647 deletions(-) delete mode 100644 include/vulkan/vulkan-130.h delete mode 100644 include/vulkan/vulkan-90.h diff --git a/include/vulkan/vulkan-130.h b/include/vulkan/vulkan-130.h deleted file mode 100644 index 75ae36766a6..00000000000 --- a/include/vulkan/vulkan-130.h +++ /dev/null @@ -1,2753 +0,0 @@ -#ifndef __vulkan_h_ -#define __vulkan_h_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015 The Khronos Group Inc. -** -** Permission is hereby granted, free of charge, to any person obtaining a -** copy of this software and/or associated documentation files (the -** "Materials"), to deal in the Materials without restriction, including -** without limitation the rights to use, copy, modify, merge, publish, -** distribute, sublicense, and/or sell copies of the Materials, and to -** permit persons to whom the Materials are furnished to do so, subject to -** the following conditions: -** -** The above copyright notice and this permission notice shall be included -** in all copies or substantial portions of the Materials. -** -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -** Generated on date 20150620 -*/ - - -#define VK_VERSION_1_0 1 -#include "vk_platform.h" - -#define VK_MAKE_VERSION(major, minor, patch) \ - ((major << 22) | (minor << 12) | patch) - -// Vulkan API version supported by this file -#define VK_API_VERSION VK_MAKE_VERSION(0, 130, 0) - -#if defined (__cplusplus) && (VK_UINTPTRLEAST64_MAX == UINTPTR_MAX) - #define VK_TYPE_SAFE_COMPATIBLE_HANDLES 1 -#endif - -#if defined(VK_TYPE_SAFE_COMPATIBLE_HANDLES) && !defined(VK_DISABLE_TYPE_SAFE_HANDLES) - #define VK_DEFINE_PTR_HANDLE(_obj) struct _obj##_T { char _dummy; }; typedef _obj##_T* _obj; - #define VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj; - - #define VK_DEFINE_BASE_HANDLE(_obj) VK_DEFINE_PTR_HANDLE(_obj) - #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) - #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) -#else - #define VK_DEFINE_BASE_HANDLE(_obj) typedef VkUintPtrLeast64 _obj; - #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) typedef uintptr_t _obj; - #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) typedef VkUintPtrLeast64 _obj; -#endif - - -#define VK_MAX_PHYSICAL_DEVICE_NAME 256 -#define VK_UUID_LENGTH 16 -#define VK_MAX_EXTENSION_NAME 256 -#define VK_MAX_MEMORY_TYPES 32 -#define VK_MAX_MEMORY_HEAPS 16 -#define VK_LOD_CLAMP_NONE MAX_FLOAT -#define VK_LAST_MIP_LEVEL UINT32_MAX -#define VK_LAST_ARRAY_SLICE UINT32_MAX -#define VK_WHOLE_SIZE UINT64_MAX -#define VK_TRUE 1 -#define VK_FALSE 0 -#define VK_NULL_HANDLE 0 - -VK_DEFINE_BASE_HANDLE(VkObject) -VK_DEFINE_DISP_SUBCLASS_HANDLE(VkInstance, VkObject) -VK_DEFINE_DISP_SUBCLASS_HANDLE(VkPhysicalDevice, VkObject) -VK_DEFINE_DISP_SUBCLASS_HANDLE(VkDevice, VkObject) -VK_DEFINE_DISP_SUBCLASS_HANDLE(VkQueue, VkObject) -VK_DEFINE_DISP_SUBCLASS_HANDLE(VkCmdBuffer, VkObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkNonDispatchable, VkObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFence, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDeviceMemory, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBuffer, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImage, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSemaphore, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkEvent, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkQueryPool, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBufferView, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImageView, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkColorAttachmentView, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDepthStencilView, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShaderModule, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShader, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineCache, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineLayout, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipeline, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSetLayout, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSampler, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorPool, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSet, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicStateObject, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicVpState, VkDynamicStateObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicRsState, VkDynamicStateObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicCbState, VkDynamicStateObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicDsState, VkDynamicStateObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFramebuffer, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable) - - -typedef enum { - VK_SUCCESS = 0, - VK_UNSUPPORTED = 1, - VK_NOT_READY = 2, - VK_TIMEOUT = 3, - VK_EVENT_SET = 4, - VK_EVENT_RESET = 5, - VK_ERROR_UNKNOWN = -1, - VK_ERROR_UNAVAILABLE = -2, - VK_ERROR_INITIALIZATION_FAILED = -3, - VK_ERROR_OUT_OF_HOST_MEMORY = -4, - VK_ERROR_OUT_OF_DEVICE_MEMORY = -5, - VK_ERROR_DEVICE_ALREADY_CREATED = -6, - VK_ERROR_DEVICE_LOST = -7, - VK_ERROR_INVALID_POINTER = -8, - VK_ERROR_INVALID_VALUE = -9, - VK_ERROR_INVALID_HANDLE = -10, - VK_ERROR_INVALID_ORDINAL = -11, - VK_ERROR_INVALID_MEMORY_SIZE = -12, - VK_ERROR_INVALID_EXTENSION = -13, - VK_ERROR_INVALID_FLAGS = -14, - VK_ERROR_INVALID_ALIGNMENT = -15, - VK_ERROR_INVALID_FORMAT = -16, - VK_ERROR_INVALID_IMAGE = -17, - VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -18, - VK_ERROR_INVALID_QUEUE_TYPE = -19, - VK_ERROR_INVALID_OBJECT_TYPE = -20, - VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -21, - VK_ERROR_BAD_SHADER_CODE = -22, - VK_ERROR_BAD_PIPELINE_DATA = -23, - VK_ERROR_NOT_MAPPABLE = -24, - VK_ERROR_MEMORY_MAP_FAILED = -25, - VK_ERROR_MEMORY_UNMAP_FAILED = -26, - VK_ERROR_INCOMPATIBLE_DEVICE = -27, - VK_ERROR_INCOMPATIBLE_DRIVER = -28, - VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -29, - VK_ERROR_BUILDING_COMMAND_BUFFER = -30, - VK_ERROR_MEMORY_NOT_BOUND = -31, - VK_ERROR_INCOMPATIBLE_QUEUE = -32, - VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_QUEUE, - VK_RESULT_END_RANGE = VK_EVENT_RESET, - VK_RESULT_NUM = (VK_EVENT_RESET - VK_ERROR_INCOMPATIBLE_QUEUE + 1), - VK_RESULT_MAX_ENUM = 0x7FFFFFFF -} VkResult; - -typedef enum { - VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, - VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, - VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3, - VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 4, - VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 5, - VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 6, - VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 7, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 8, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 33, - VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 34, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 35, - VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 36, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 37, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 38, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 39, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 40, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 41, - VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 42, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 43, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 44, - VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 45, - VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 46, - VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, - VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, - VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), - VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkStructureType; - -typedef enum { - VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0, - VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1, - VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2, - VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3, - VK_SYSTEM_ALLOC_TYPE_DEBUG = 4, - VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT, - VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG, - VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1), - VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkSystemAllocType; - -typedef enum { - VK_FORMAT_UNDEFINED = 0, - VK_FORMAT_R4G4_UNORM = 1, - VK_FORMAT_R4G4_USCALED = 2, - VK_FORMAT_R4G4B4A4_UNORM = 3, - VK_FORMAT_R4G4B4A4_USCALED = 4, - VK_FORMAT_R5G6B5_UNORM = 5, - VK_FORMAT_R5G6B5_USCALED = 6, - VK_FORMAT_R5G5B5A1_UNORM = 7, - VK_FORMAT_R5G5B5A1_USCALED = 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_R8G8B8A8_UNORM = 30, - VK_FORMAT_R8G8B8A8_SNORM = 31, - VK_FORMAT_R8G8B8A8_USCALED = 32, - VK_FORMAT_R8G8B8A8_SSCALED = 33, - VK_FORMAT_R8G8B8A8_UINT = 34, - VK_FORMAT_R8G8B8A8_SINT = 35, - VK_FORMAT_R8G8B8A8_SRGB = 36, - VK_FORMAT_R10G10B10A2_UNORM = 37, - VK_FORMAT_R10G10B10A2_SNORM = 38, - VK_FORMAT_R10G10B10A2_USCALED = 39, - VK_FORMAT_R10G10B10A2_SSCALED = 40, - VK_FORMAT_R10G10B10A2_UINT = 41, - VK_FORMAT_R10G10B10A2_SINT = 42, - VK_FORMAT_R16_UNORM = 43, - VK_FORMAT_R16_SNORM = 44, - VK_FORMAT_R16_USCALED = 45, - VK_FORMAT_R16_SSCALED = 46, - VK_FORMAT_R16_UINT = 47, - VK_FORMAT_R16_SINT = 48, - VK_FORMAT_R16_SFLOAT = 49, - VK_FORMAT_R16G16_UNORM = 50, - VK_FORMAT_R16G16_SNORM = 51, - VK_FORMAT_R16G16_USCALED = 52, - VK_FORMAT_R16G16_SSCALED = 53, - VK_FORMAT_R16G16_UINT = 54, - VK_FORMAT_R16G16_SINT = 55, - VK_FORMAT_R16G16_SFLOAT = 56, - VK_FORMAT_R16G16B16_UNORM = 57, - VK_FORMAT_R16G16B16_SNORM = 58, - VK_FORMAT_R16G16B16_USCALED = 59, - VK_FORMAT_R16G16B16_SSCALED = 60, - VK_FORMAT_R16G16B16_UINT = 61, - VK_FORMAT_R16G16B16_SINT = 62, - VK_FORMAT_R16G16B16_SFLOAT = 63, - VK_FORMAT_R16G16B16A16_UNORM = 64, - VK_FORMAT_R16G16B16A16_SNORM = 65, - VK_FORMAT_R16G16B16A16_USCALED = 66, - VK_FORMAT_R16G16B16A16_SSCALED = 67, - VK_FORMAT_R16G16B16A16_UINT = 68, - VK_FORMAT_R16G16B16A16_SINT = 69, - VK_FORMAT_R16G16B16A16_SFLOAT = 70, - VK_FORMAT_R32_UINT = 71, - VK_FORMAT_R32_SINT = 72, - VK_FORMAT_R32_SFLOAT = 73, - VK_FORMAT_R32G32_UINT = 74, - VK_FORMAT_R32G32_SINT = 75, - VK_FORMAT_R32G32_SFLOAT = 76, - VK_FORMAT_R32G32B32_UINT = 77, - VK_FORMAT_R32G32B32_SINT = 78, - VK_FORMAT_R32G32B32_SFLOAT = 79, - VK_FORMAT_R32G32B32A32_UINT = 80, - VK_FORMAT_R32G32B32A32_SINT = 81, - VK_FORMAT_R32G32B32A32_SFLOAT = 82, - VK_FORMAT_R64_SFLOAT = 83, - VK_FORMAT_R64G64_SFLOAT = 84, - VK_FORMAT_R64G64B64_SFLOAT = 85, - VK_FORMAT_R64G64B64A64_SFLOAT = 86, - VK_FORMAT_R11G11B10_UFLOAT = 87, - VK_FORMAT_R9G9B9E5_UFLOAT = 88, - VK_FORMAT_D16_UNORM = 89, - VK_FORMAT_D24_UNORM = 90, - VK_FORMAT_D32_SFLOAT = 91, - VK_FORMAT_S8_UINT = 92, - VK_FORMAT_D16_UNORM_S8_UINT = 93, - VK_FORMAT_D24_UNORM_S8_UINT = 94, - VK_FORMAT_D32_SFLOAT_S8_UINT = 95, - VK_FORMAT_BC1_RGB_UNORM = 96, - VK_FORMAT_BC1_RGB_SRGB = 97, - VK_FORMAT_BC1_RGBA_UNORM = 98, - VK_FORMAT_BC1_RGBA_SRGB = 99, - VK_FORMAT_BC2_UNORM = 100, - VK_FORMAT_BC2_SRGB = 101, - VK_FORMAT_BC3_UNORM = 102, - VK_FORMAT_BC3_SRGB = 103, - VK_FORMAT_BC4_UNORM = 104, - VK_FORMAT_BC4_SNORM = 105, - VK_FORMAT_BC5_UNORM = 106, - VK_FORMAT_BC5_SNORM = 107, - VK_FORMAT_BC6H_UFLOAT = 108, - VK_FORMAT_BC6H_SFLOAT = 109, - VK_FORMAT_BC7_UNORM = 110, - VK_FORMAT_BC7_SRGB = 111, - VK_FORMAT_ETC2_R8G8B8_UNORM = 112, - VK_FORMAT_ETC2_R8G8B8_SRGB = 113, - VK_FORMAT_ETC2_R8G8B8A1_UNORM = 114, - VK_FORMAT_ETC2_R8G8B8A1_SRGB = 115, - VK_FORMAT_ETC2_R8G8B8A8_UNORM = 116, - VK_FORMAT_ETC2_R8G8B8A8_SRGB = 117, - VK_FORMAT_EAC_R11_UNORM = 118, - VK_FORMAT_EAC_R11_SNORM = 119, - VK_FORMAT_EAC_R11G11_UNORM = 120, - VK_FORMAT_EAC_R11G11_SNORM = 121, - VK_FORMAT_ASTC_4x4_UNORM = 122, - VK_FORMAT_ASTC_4x4_SRGB = 123, - VK_FORMAT_ASTC_5x4_UNORM = 124, - VK_FORMAT_ASTC_5x4_SRGB = 125, - VK_FORMAT_ASTC_5x5_UNORM = 126, - VK_FORMAT_ASTC_5x5_SRGB = 127, - VK_FORMAT_ASTC_6x5_UNORM = 128, - VK_FORMAT_ASTC_6x5_SRGB = 129, - VK_FORMAT_ASTC_6x6_UNORM = 130, - VK_FORMAT_ASTC_6x6_SRGB = 131, - VK_FORMAT_ASTC_8x5_UNORM = 132, - VK_FORMAT_ASTC_8x5_SRGB = 133, - VK_FORMAT_ASTC_8x6_UNORM = 134, - VK_FORMAT_ASTC_8x6_SRGB = 135, - VK_FORMAT_ASTC_8x8_UNORM = 136, - VK_FORMAT_ASTC_8x8_SRGB = 137, - VK_FORMAT_ASTC_10x5_UNORM = 138, - VK_FORMAT_ASTC_10x5_SRGB = 139, - VK_FORMAT_ASTC_10x6_UNORM = 140, - VK_FORMAT_ASTC_10x6_SRGB = 141, - VK_FORMAT_ASTC_10x8_UNORM = 142, - VK_FORMAT_ASTC_10x8_SRGB = 143, - VK_FORMAT_ASTC_10x10_UNORM = 144, - VK_FORMAT_ASTC_10x10_SRGB = 145, - VK_FORMAT_ASTC_12x10_UNORM = 146, - VK_FORMAT_ASTC_12x10_SRGB = 147, - VK_FORMAT_ASTC_12x12_UNORM = 148, - VK_FORMAT_ASTC_12x12_SRGB = 149, - VK_FORMAT_B4G4R4A4_UNORM = 150, - VK_FORMAT_B5G5R5A1_UNORM = 151, - VK_FORMAT_B5G6R5_UNORM = 152, - VK_FORMAT_B5G6R5_USCALED = 153, - VK_FORMAT_B8G8R8_UNORM = 154, - VK_FORMAT_B8G8R8_SNORM = 155, - VK_FORMAT_B8G8R8_USCALED = 156, - VK_FORMAT_B8G8R8_SSCALED = 157, - VK_FORMAT_B8G8R8_UINT = 158, - VK_FORMAT_B8G8R8_SINT = 159, - VK_FORMAT_B8G8R8_SRGB = 160, - VK_FORMAT_B8G8R8A8_UNORM = 161, - VK_FORMAT_B8G8R8A8_SNORM = 162, - VK_FORMAT_B8G8R8A8_USCALED = 163, - VK_FORMAT_B8G8R8A8_SSCALED = 164, - VK_FORMAT_B8G8R8A8_UINT = 165, - VK_FORMAT_B8G8R8A8_SINT = 166, - VK_FORMAT_B8G8R8A8_SRGB = 167, - VK_FORMAT_B10G10R10A2_UNORM = 168, - VK_FORMAT_B10G10R10A2_SNORM = 169, - VK_FORMAT_B10G10R10A2_USCALED = 170, - VK_FORMAT_B10G10R10A2_SSCALED = 171, - VK_FORMAT_B10G10R10A2_UINT = 172, - VK_FORMAT_B10G10R10A2_SINT = 173, - VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, - VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT, - VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1), - VK_FORMAT_MAX_ENUM = 0x7FFFFFFF -} VkFormat; - -typedef enum { - 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, - VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, - VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, - VK_PHYSICAL_DEVICE_TYPE_NUM = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), - VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkPhysicalDeviceType; - -typedef enum { - VK_OBJECT_TYPE_INSTANCE = 0, - VK_OBJECT_TYPE_PHYSICAL_DEVICE = 1, - VK_OBJECT_TYPE_DEVICE = 2, - VK_OBJECT_TYPE_QUEUE = 3, - VK_OBJECT_TYPE_COMMAND_BUFFER = 4, - VK_OBJECT_TYPE_DEVICE_MEMORY = 5, - VK_OBJECT_TYPE_BUFFER = 6, - VK_OBJECT_TYPE_BUFFER_VIEW = 7, - VK_OBJECT_TYPE_IMAGE = 8, - VK_OBJECT_TYPE_IMAGE_VIEW = 9, - VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW = 10, - VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW = 11, - VK_OBJECT_TYPE_SHADER_MODULE = 12, - VK_OBJECT_TYPE_SHADER = 13, - VK_OBJECT_TYPE_PIPELINE = 14, - VK_OBJECT_TYPE_PIPELINE_LAYOUT = 15, - VK_OBJECT_TYPE_SAMPLER = 16, - VK_OBJECT_TYPE_DESCRIPTOR_SET = 17, - VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 18, - VK_OBJECT_TYPE_DESCRIPTOR_POOL = 19, - VK_OBJECT_TYPE_DYNAMIC_VP_STATE = 20, - VK_OBJECT_TYPE_DYNAMIC_RS_STATE = 21, - VK_OBJECT_TYPE_DYNAMIC_CB_STATE = 22, - VK_OBJECT_TYPE_DYNAMIC_DS_STATE = 23, - VK_OBJECT_TYPE_FENCE = 24, - VK_OBJECT_TYPE_SEMAPHORE = 25, - VK_OBJECT_TYPE_EVENT = 26, - VK_OBJECT_TYPE_QUERY_POOL = 27, - VK_OBJECT_TYPE_FRAMEBUFFER = 28, - VK_OBJECT_TYPE_RENDER_PASS = 29, - VK_OBJECT_TYPE_PIPELINE_CACHE = 30, - VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE, - VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_PIPELINE_CACHE, - VK_OBJECT_TYPE_NUM = (VK_OBJECT_TYPE_PIPELINE_CACHE - VK_OBJECT_TYPE_INSTANCE + 1), - VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkObjectType; - -typedef enum { - VK_IMAGE_ASPECT_COLOR = 0, - VK_IMAGE_ASPECT_DEPTH = 1, - VK_IMAGE_ASPECT_STENCIL = 2, - VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR, - VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_STENCIL, - VK_IMAGE_ASPECT_NUM = (VK_IMAGE_ASPECT_STENCIL - VK_IMAGE_ASPECT_COLOR + 1), - VK_IMAGE_ASPECT_MAX_ENUM = 0x7FFFFFFF -} VkImageAspect; - -typedef enum { - VK_QUERY_TYPE_OCCLUSION = 0, - VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, - VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, - VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS, - VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_PIPELINE_STATISTICS - VK_QUERY_TYPE_OCCLUSION + 1), - VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkQueryType; - -typedef enum { - VK_BUFFER_VIEW_TYPE_RAW = 0, - VK_BUFFER_VIEW_TYPE_FORMATTED = 1, - VK_BUFFER_VIEW_TYPE_BEGIN_RANGE = VK_BUFFER_VIEW_TYPE_RAW, - VK_BUFFER_VIEW_TYPE_END_RANGE = VK_BUFFER_VIEW_TYPE_FORMATTED, - VK_BUFFER_VIEW_TYPE_NUM = (VK_BUFFER_VIEW_TYPE_FORMATTED - VK_BUFFER_VIEW_TYPE_RAW + 1), - VK_BUFFER_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkBufferViewType; - -typedef enum { - VK_IMAGE_TYPE_1D = 0, - VK_IMAGE_TYPE_2D = 1, - VK_IMAGE_TYPE_3D = 2, - VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, - VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, - VK_IMAGE_TYPE_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), - VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageType; - -typedef enum { - VK_IMAGE_TILING_LINEAR = 0, - VK_IMAGE_TILING_OPTIMAL = 1, - VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_LINEAR, - VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_OPTIMAL - VK_IMAGE_TILING_LINEAR + 1), - VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF -} VkImageTiling; - -typedef enum { - 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, - VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, - VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, - VK_IMAGE_VIEW_TYPE_NUM = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), - VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageViewType; - -typedef enum { - VK_CHANNEL_SWIZZLE_ZERO = 0, - VK_CHANNEL_SWIZZLE_ONE = 1, - VK_CHANNEL_SWIZZLE_R = 2, - VK_CHANNEL_SWIZZLE_G = 3, - VK_CHANNEL_SWIZZLE_B = 4, - VK_CHANNEL_SWIZZLE_A = 5, - VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO, - VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A, - VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_ZERO + 1), - VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF -} VkChannelSwizzle; - -typedef enum { - VK_SHADER_STAGE_VERTEX = 0, - VK_SHADER_STAGE_TESS_CONTROL = 1, - VK_SHADER_STAGE_TESS_EVALUATION = 2, - VK_SHADER_STAGE_GEOMETRY = 3, - VK_SHADER_STAGE_FRAGMENT = 4, - VK_SHADER_STAGE_COMPUTE = 5, - VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX, - VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE, - VK_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1), - VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF -} VkShaderStage; - -typedef enum { - VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0, - VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1, - VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX, - VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_INSTANCE, - VK_VERTEX_INPUT_STEP_RATE_NUM = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1), - VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF -} VkVertexInputStepRate; - -typedef enum { - 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_ADJ = 6, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9, - VK_PRIMITIVE_TOPOLOGY_PATCH = 10, - VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, - VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH, - VK_PRIMITIVE_TOPOLOGY_NUM = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), - VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF -} VkPrimitiveTopology; - -typedef enum { - VK_FILL_MODE_POINTS = 0, - VK_FILL_MODE_WIREFRAME = 1, - VK_FILL_MODE_SOLID = 2, - VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_POINTS, - VK_FILL_MODE_END_RANGE = VK_FILL_MODE_SOLID, - VK_FILL_MODE_NUM = (VK_FILL_MODE_SOLID - VK_FILL_MODE_POINTS + 1), - VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF -} VkFillMode; - -typedef enum { - VK_CULL_MODE_NONE = 0, - VK_CULL_MODE_FRONT = 1, - VK_CULL_MODE_BACK = 2, - VK_CULL_MODE_FRONT_AND_BACK = 3, - VK_CULL_MODE_BEGIN_RANGE = VK_CULL_MODE_NONE, - VK_CULL_MODE_END_RANGE = VK_CULL_MODE_FRONT_AND_BACK, - VK_CULL_MODE_NUM = (VK_CULL_MODE_FRONT_AND_BACK - VK_CULL_MODE_NONE + 1), - VK_CULL_MODE_MAX_ENUM = 0x7FFFFFFF -} VkCullMode; - -typedef enum { - VK_FRONT_FACE_CCW = 0, - VK_FRONT_FACE_CW = 1, - VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW, - VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW, - VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1), - VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF -} VkFrontFace; - -typedef enum { - VK_COMPARE_OP_NEVER = 0, - VK_COMPARE_OP_LESS = 1, - VK_COMPARE_OP_EQUAL = 2, - VK_COMPARE_OP_LESS_EQUAL = 3, - VK_COMPARE_OP_GREATER = 4, - VK_COMPARE_OP_NOT_EQUAL = 5, - VK_COMPARE_OP_GREATER_EQUAL = 6, - VK_COMPARE_OP_ALWAYS = 7, - VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, - VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, - VK_COMPARE_OP_NUM = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), - VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF -} VkCompareOp; - -typedef enum { - VK_STENCIL_OP_KEEP = 0, - VK_STENCIL_OP_ZERO = 1, - VK_STENCIL_OP_REPLACE = 2, - VK_STENCIL_OP_INC_CLAMP = 3, - VK_STENCIL_OP_DEC_CLAMP = 4, - VK_STENCIL_OP_INVERT = 5, - VK_STENCIL_OP_INC_WRAP = 6, - VK_STENCIL_OP_DEC_WRAP = 7, - VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, - VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP, - VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1), - VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF -} VkStencilOp; - -typedef enum { - 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_NOOP = 5, - VK_LOGIC_OP_XOR = 6, - VK_LOGIC_OP_OR = 7, - VK_LOGIC_OP_NOR = 8, - VK_LOGIC_OP_EQUIV = 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, - VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, - VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, - VK_LOGIC_OP_NUM = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), - VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF -} VkLogicOp; - -typedef enum { - VK_BLEND_ZERO = 0, - VK_BLEND_ONE = 1, - VK_BLEND_SRC_COLOR = 2, - VK_BLEND_ONE_MINUS_SRC_COLOR = 3, - VK_BLEND_DEST_COLOR = 4, - VK_BLEND_ONE_MINUS_DEST_COLOR = 5, - VK_BLEND_SRC_ALPHA = 6, - VK_BLEND_ONE_MINUS_SRC_ALPHA = 7, - VK_BLEND_DEST_ALPHA = 8, - VK_BLEND_ONE_MINUS_DEST_ALPHA = 9, - VK_BLEND_CONSTANT_COLOR = 10, - VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11, - VK_BLEND_CONSTANT_ALPHA = 12, - VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 13, - VK_BLEND_SRC_ALPHA_SATURATE = 14, - VK_BLEND_SRC1_COLOR = 15, - VK_BLEND_ONE_MINUS_SRC1_COLOR = 16, - VK_BLEND_SRC1_ALPHA = 17, - VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18, - VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO, - VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA, - VK_BLEND_NUM = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1), - VK_BLEND_MAX_ENUM = 0x7FFFFFFF -} VkBlend; - -typedef enum { - 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, - VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, - VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, - VK_BLEND_OP_NUM = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), - VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF -} VkBlendOp; - -typedef enum { - VK_TEX_FILTER_NEAREST = 0, - VK_TEX_FILTER_LINEAR = 1, - VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST, - VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR, - VK_TEX_FILTER_NUM = (VK_TEX_FILTER_LINEAR - VK_TEX_FILTER_NEAREST + 1), - VK_TEX_FILTER_MAX_ENUM = 0x7FFFFFFF -} VkTexFilter; - -typedef enum { - VK_TEX_MIPMAP_MODE_BASE = 0, - VK_TEX_MIPMAP_MODE_NEAREST = 1, - VK_TEX_MIPMAP_MODE_LINEAR = 2, - VK_TEX_MIPMAP_MODE_BEGIN_RANGE = VK_TEX_MIPMAP_MODE_BASE, - VK_TEX_MIPMAP_MODE_END_RANGE = VK_TEX_MIPMAP_MODE_LINEAR, - VK_TEX_MIPMAP_MODE_NUM = (VK_TEX_MIPMAP_MODE_LINEAR - VK_TEX_MIPMAP_MODE_BASE + 1), - VK_TEX_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF -} VkTexMipmapMode; - -typedef enum { - VK_TEX_ADDRESS_WRAP = 0, - VK_TEX_ADDRESS_MIRROR = 1, - VK_TEX_ADDRESS_CLAMP = 2, - VK_TEX_ADDRESS_MIRROR_ONCE = 3, - VK_TEX_ADDRESS_CLAMP_BORDER = 4, - VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_WRAP, - VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_CLAMP_BORDER, - VK_TEX_ADDRESS_NUM = (VK_TEX_ADDRESS_CLAMP_BORDER - VK_TEX_ADDRESS_WRAP + 1), - VK_TEX_ADDRESS_MAX_ENUM = 0x7FFFFFFF -} VkTexAddress; - -typedef enum { - 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, - VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, - VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, - VK_BORDER_COLOR_NUM = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), - VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF -} VkBorderColor; - -typedef enum { - 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_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, - VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, - VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC - VK_DESCRIPTOR_TYPE_SAMPLER + 1), - VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorType; - -typedef enum { - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0, - VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1, - VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, - VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC, - VK_DESCRIPTOR_POOL_USAGE_NUM = (VK_DESCRIPTOR_POOL_USAGE_DYNAMIC - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT + 1), - VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorPoolUsage; - -typedef enum { - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0, - VK_DESCRIPTOR_SET_USAGE_STATIC = 1, - VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, - VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC, - VK_DESCRIPTOR_SET_USAGE_NUM = (VK_DESCRIPTOR_SET_USAGE_STATIC - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT + 1), - VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorSetUsage; - -typedef enum { - 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_SOURCE_OPTIMAL = 6, - VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7, - VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, - VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, - VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL - VK_IMAGE_LAYOUT_UNDEFINED + 1), - VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF -} VkImageLayout; - -typedef enum { - VK_ATTACHMENT_LOAD_OP_LOAD = 0, - VK_ATTACHMENT_LOAD_OP_CLEAR = 1, - VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, - VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, - VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, - VK_ATTACHMENT_LOAD_OP_NUM = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), - VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentLoadOp; - -typedef enum { - VK_ATTACHMENT_STORE_OP_STORE = 0, - VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 1, - VK_ATTACHMENT_STORE_OP_DONT_CARE = 2, - VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, - VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, - VK_ATTACHMENT_STORE_OP_NUM = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), - VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentStoreOp; - -typedef enum { - VK_CMD_BUFFER_LEVEL_PRIMARY = 0, - VK_CMD_BUFFER_LEVEL_SECONDARY = 1, - VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY, - VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY, - VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1), - VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF -} VkCmdBufferLevel; - -typedef enum { - VK_PIPELINE_BIND_POINT_COMPUTE = 0, - VK_PIPELINE_BIND_POINT_GRAPHICS = 1, - VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, - VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, - VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_GRAPHICS - VK_PIPELINE_BIND_POINT_COMPUTE + 1), - VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF -} VkPipelineBindPoint; - -typedef enum { - VK_STATE_BIND_POINT_VIEWPORT = 0, - VK_STATE_BIND_POINT_RASTER = 1, - VK_STATE_BIND_POINT_COLOR_BLEND = 2, - VK_STATE_BIND_POINT_DEPTH_STENCIL = 3, - VK_STATE_BIND_POINT_BEGIN_RANGE = VK_STATE_BIND_POINT_VIEWPORT, - VK_STATE_BIND_POINT_END_RANGE = VK_STATE_BIND_POINT_DEPTH_STENCIL, - VK_STATE_BIND_POINT_NUM = (VK_STATE_BIND_POINT_DEPTH_STENCIL - VK_STATE_BIND_POINT_VIEWPORT + 1), - VK_STATE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF -} VkStateBindPoint; - -typedef enum { - VK_INDEX_TYPE_UINT16 = 0, - VK_INDEX_TYPE_UINT32 = 1, - VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, - VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, - VK_INDEX_TYPE_NUM = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), - VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkIndexType; - -typedef enum { - VK_PIPE_EVENT_TOP_OF_PIPE = 0, - VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE = 1, - VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE = 2, - VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE = 3, - VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE = 4, - VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE = 5, - VK_PIPE_EVENT_TRANSFER_COMPLETE = 6, - VK_PIPE_EVENT_COMMANDS_COMPLETE = 7, - VK_PIPE_EVENT_CPU_SIGNAL = 8, - VK_PIPE_EVENT_BEGIN_RANGE = VK_PIPE_EVENT_TOP_OF_PIPE, - VK_PIPE_EVENT_END_RANGE = VK_PIPE_EVENT_CPU_SIGNAL, - VK_PIPE_EVENT_NUM = (VK_PIPE_EVENT_CPU_SIGNAL - VK_PIPE_EVENT_TOP_OF_PIPE + 1), - VK_PIPE_EVENT_MAX_ENUM = 0x7FFFFFFF -} VkPipeEvent; - -typedef enum { - VK_WAIT_EVENT_TOP_OF_PIPE = 1, - VK_WAIT_EVENT_BEFORE_RASTERIZATION = 2, - VK_WAIT_EVENT_BEGIN_RANGE = VK_WAIT_EVENT_TOP_OF_PIPE, - VK_WAIT_EVENT_END_RANGE = VK_WAIT_EVENT_BEFORE_RASTERIZATION, - VK_WAIT_EVENT_NUM = (VK_WAIT_EVENT_BEFORE_RASTERIZATION - VK_WAIT_EVENT_TOP_OF_PIPE + 1), - VK_WAIT_EVENT_MAX_ENUM = 0x7FFFFFFF -} VkWaitEvent; - -typedef enum { - VK_TIMESTAMP_TYPE_TOP = 0, - VK_TIMESTAMP_TYPE_BOTTOM = 1, - VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TYPE_TOP, - VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_TYPE_BOTTOM, - VK_TIMESTAMP_TYPE_NUM = (VK_TIMESTAMP_TYPE_BOTTOM - VK_TIMESTAMP_TYPE_TOP + 1), - VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkTimestampType; - -typedef enum { - VK_RENDER_PASS_CONTENTS_INLINE = 0, - VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1, - VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE, - VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS, - VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1), - VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF -} VkRenderPassContents; - - -typedef enum { - VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, - VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, - VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, - VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, - VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, - VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, - VK_FORMAT_FEATURE_CONVERSION_BIT = 0x00000400, -} VkFormatFeatureFlagBits; -typedef VkFlags VkFormatFeatureFlags; - -typedef enum { - VK_QUEUE_GRAPHICS_BIT = 0x00000001, - VK_QUEUE_COMPUTE_BIT = 0x00000002, - VK_QUEUE_DMA_BIT = 0x00000004, - VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008, - VK_QUEUE_EXTENDED_BIT = 0x40000000, -} VkQueueFlagBits; -typedef VkFlags VkQueueFlags; - -typedef enum { - VK_MEMORY_PROPERTY_DEVICE_ONLY = 0, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001, - VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, - VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004, - VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008, -} VkMemoryPropertyFlagBits; -typedef VkFlags VkMemoryPropertyFlags; - -typedef enum { - VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001, -} VkMemoryHeapFlagBits; -typedef VkFlags VkMemoryHeapFlags; - -typedef enum { - VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001, -} VkDeviceCreateFlagBits; -typedef VkFlags VkDeviceCreateFlags; -typedef VkFlags VkMemoryMapFlags; - -typedef enum { - VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, -} VkFenceCreateFlagBits; -typedef VkFlags VkFenceCreateFlags; -typedef VkFlags VkSemaphoreCreateFlags; -typedef VkFlags VkEventCreateFlags; - -typedef enum { - VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001, - VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002, - VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004, - VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008, - VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010, - VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020, - VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040, - VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080, - VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100, - VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200, - VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400, -} VkQueryPipelineStatisticFlagBits; -typedef VkFlags VkQueryPipelineStatisticFlags; - -typedef enum { - VK_QUERY_RESULT_DEFAULT = 0, - VK_QUERY_RESULT_64_BIT = 0x00000001, - VK_QUERY_RESULT_WAIT_BIT = 0x00000002, - VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, - VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, -} VkQueryResultFlagBits; -typedef VkFlags VkQueryResultFlags; - -typedef enum { - VK_BUFFER_USAGE_GENERAL = 0, - VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, - VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, - VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, - VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, - VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, - VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, - VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, -} VkBufferUsageFlagBits; -typedef VkFlags VkBufferUsageFlags; - -typedef enum { - VK_BUFFER_CREATE_SPARSE_BIT = 0x00000001, -} VkBufferCreateFlagBits; -typedef VkFlags VkBufferCreateFlags; - -typedef enum { - VK_IMAGE_USAGE_GENERAL = 0, - VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, - VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, - VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, - VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000020, - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, -} VkImageUsageFlagBits; -typedef VkFlags VkImageUsageFlags; - -typedef enum { - VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001, - VK_IMAGE_CREATE_SPARSE_BIT = 0x00000002, - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000004, - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000008, -} VkImageCreateFlagBits; -typedef VkFlags VkImageCreateFlags; - -typedef enum { - VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, - VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, -} VkDepthStencilViewCreateFlagBits; -typedef VkFlags VkDepthStencilViewCreateFlags; -typedef VkFlags VkShaderModuleCreateFlags; -typedef VkFlags VkShaderCreateFlags; - -typedef enum { - VK_CHANNEL_R_BIT = 0x00000001, - VK_CHANNEL_G_BIT = 0x00000002, - VK_CHANNEL_B_BIT = 0x00000004, - VK_CHANNEL_A_BIT = 0x00000008, -} VkChannelFlagBits; -typedef VkFlags VkChannelFlags; - -typedef enum { - VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, - VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, - VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, -} VkPipelineCreateFlagBits; -typedef VkFlags VkPipelineCreateFlags; - -typedef enum { - VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, - VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002, - VK_SHADER_STAGE_TESS_EVALUATION_BIT = 0x00000004, - VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, - VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, - VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, - VK_SHADER_STAGE_ALL = 0x7FFFFFFF, -} VkShaderStageFlagBits; -typedef VkFlags VkShaderStageFlags; -typedef VkFlags VkCmdBufferCreateFlags; - -typedef enum { - VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001, - VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, - VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, - VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, - VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010, -} VkCmdBufferOptimizeFlagBits; -typedef VkFlags VkCmdBufferOptimizeFlags; - -typedef enum { - VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, - VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, - VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, -} VkImageAspectFlagBits; -typedef VkFlags VkImageAspectFlags; - -typedef enum { - VK_PIPE_EVENT_TOP_OF_PIPE_BIT = 0x00000001, - VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE_BIT = 0x00000002, - VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE_BIT = 0x00000004, - VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE_BIT = 0x00000008, - VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE_BIT = 0x00000010, - VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE_BIT = 0x00000020, - VK_PIPE_EVENT_TRANSFER_COMPLETE_BIT = 0x00000040, - VK_PIPE_EVENT_COMMANDS_COMPLETE_BIT = 0x00000080, - VK_PIPE_EVENT_CPU_SIGNAL_BIT = 0x00000100, -} VkPipeEventFlagBits; -typedef VkFlags VkPipeEventFlags; - -typedef enum { - VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, -} VkQueryControlFlagBits; -typedef VkFlags VkQueryControlFlags; - -typedef enum { - VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, - VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, - VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, - VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, - VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010, -} VkMemoryOutputFlagBits; -typedef VkFlags VkMemoryOutputFlags; - -typedef enum { - VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, - VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, - VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, - VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, - VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, - VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, - VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, - VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, - VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000100, -} VkMemoryInputFlagBits; -typedef VkFlags VkMemoryInputFlags; - -typedef struct { - VkStructureType sType; - const void* pNext; - const char* pAppName; - uint32_t appVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; -} VkApplicationInfo; - -typedef void* (VKAPI *PFN_vkAllocFunction)( - void* pUserData, - size_t size, - size_t alignment, - VkSystemAllocType allocType); - -typedef void (VKAPI *PFN_vkFreeFunction)( - void* pUserData, - void* pMem); - -typedef struct { - void* pUserData; - PFN_vkAllocFunction pfnAlloc; - PFN_vkFreeFunction pfnFree; -} VkAllocCallbacks; - -typedef struct { - VkStructureType sType; - const void* pNext; - const VkApplicationInfo* pAppInfo; - const VkAllocCallbacks* pAllocCb; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; -} VkInstanceCreateInfo; - -typedef struct { - bool32_t robustBufferAccess; - bool32_t fullDrawIndexUint32; - bool32_t imageCubeArray; - bool32_t independentBlend; - bool32_t geometryShader; - bool32_t tessellationShader; - bool32_t sampleRateShading; - bool32_t dualSourceBlend; - bool32_t logicOp; - bool32_t instancedDrawIndirect; - bool32_t depthClip; - bool32_t depthBiasClamp; - bool32_t fillModeNonSolid; - bool32_t depthBounds; - bool32_t wideLines; - bool32_t largePoints; - bool32_t textureCompressionETC2; - bool32_t textureCompressionASTC_LDR; - bool32_t textureCompressionBC; - bool32_t pipelineStatisticsQuery; - bool32_t vertexSideEffects; - bool32_t tessellationSideEffects; - bool32_t geometrySideEffects; - bool32_t fragmentSideEffects; - bool32_t shaderTessellationPointSize; - bool32_t shaderGeometryPointSize; - bool32_t shaderTextureGatherExtended; - bool32_t shaderStorageImageExtendedFormats; - bool32_t shaderStorageImageMultisample; - bool32_t shaderStorageBufferArrayConstantIndexing; - bool32_t shaderStorageImageArrayConstantIndexing; - bool32_t shaderUniformBufferArrayDynamicIndexing; - bool32_t shaderSampledImageArrayDynamicIndexing; - bool32_t shaderStorageBufferArrayDynamicIndexing; - bool32_t shaderStorageImageArrayDynamicIndexing; - bool32_t shaderClipDistance; - bool32_t shaderCullDistance; - bool32_t shaderFloat64; - bool32_t shaderInt64; - bool32_t shaderFloat16; - bool32_t shaderInt16; -} VkPhysicalDeviceFeatures; - -typedef struct { - VkFormatFeatureFlags linearTilingFeatures; - VkFormatFeatureFlags optimalTilingFeatures; -} VkFormatProperties; - -typedef struct { - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - uint32_t maxTexelBufferSize; - uint32_t maxUniformBufferSize; - uint32_t maxStorageBufferSize; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - uint32_t maxBoundDescriptorSets; - uint32_t maxDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessGenLevel; - uint32_t maxTessPatchSize; - uint32_t maxTessControlPerVertexInputComponents; - uint32_t maxTessControlPerVertexOutputComponents; - uint32_t maxTessControlPerPatchOutputComponents; - uint32_t maxTessControlTotalOutputComponents; - uint32_t maxTessEvaluationInputComponents; - uint32_t maxTessEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputBuffers; - uint32_t maxFragmentDualSourceBuffers; - uint32_t maxFragmentCombinedOutputResources; - uint32_t maxComputeSharedMemorySize; - uint32_t maxComputeWorkGroupCount[3]; - uint32_t maxComputeWorkGroupInvocations; - uint32_t maxComputeWorkGroupSize[3]; - uint32_t subPixelPrecisionBits; - uint32_t subTexelPrecisionBits; - uint32_t mipmapPrecisionBits; - uint32_t maxDrawIndexedIndexValue; - uint32_t maxDrawIndirectInstanceCount; - bool32_t primitiveRestartForPatches; - float maxSamplerLodBias; - uint32_t maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxDynamicViewportStates; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - uint32_t minMemoryMapAlignment; - uint32_t minTexelBufferOffsetAlignment; - uint32_t minUniformBufferOffsetAlignment; - uint32_t minStorageBufferOffsetAlignment; - uint32_t minTexelOffset; - uint32_t maxTexelOffset; - uint32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - uint32_t maxFramebufferColorSamples; - uint32_t maxFramebufferDepthSamples; - uint32_t maxFramebufferStencilSamples; - uint32_t maxColorAttachments; - uint32_t maxSampledImageColorSamples; - uint32_t maxSampledImageDepthSamples; - uint32_t maxSampledImageIntegerSamples; - uint32_t maxStorageImageSamples; - uint32_t maxSampleMaskWords; - uint64_t timestampFrequency; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; -} VkPhysicalDeviceLimits; - -typedef struct { - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorId; - uint32_t deviceId; - VkPhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; - uint8_t pipelineCacheUUID[VK_UUID_LENGTH]; -} VkPhysicalDeviceProperties; - -typedef struct { - VkQueueFlags queueFlags; - uint32_t queueCount; - bool32_t supportsTimestamps; -} VkPhysicalDeviceQueueProperties; - -typedef struct { - VkMemoryPropertyFlags propertyFlags; - uint32_t heapIndex; -} VkMemoryType; - -typedef struct { - VkDeviceSize size; - VkMemoryHeapFlags flags; -} VkMemoryHeap; - -typedef struct { - uint32_t memoryTypeCount; - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryProperties; - -typedef void (VKAPI *PFN_vkVoidFunction)(void); -typedef struct { - uint32_t queueNodeIndex; - uint32_t queueCount; -} VkDeviceQueueCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t queueRecordCount; - const VkDeviceQueueCreateInfo* pRequestedQueues; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; - const VkPhysicalDeviceFeatures* pEnabledFeatures; - VkDeviceCreateFlags flags; -} VkDeviceCreateInfo; - -typedef struct { - char extName[VK_MAX_EXTENSION_NAME]; - uint32_t version; -} VkExtensionProperties; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDeviceSize allocationSize; - uint32_t memoryTypeIndex; -} VkMemoryAllocInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDeviceMemory mem; - VkDeviceSize offset; - VkDeviceSize size; -} VkMappedMemoryRange; - -typedef struct { - VkDeviceSize size; - VkDeviceSize alignment; - VkDeviceSize granularity; - uint32_t memoryTypeBits; -} VkMemoryRequirements; - -typedef struct { - VkImageAspect aspect; - uint32_t mipLevel; - uint32_t arraySlice; -} VkImageSubresource; - -typedef struct { - int32_t x; - int32_t y; - int32_t z; -} VkOffset3D; - -typedef struct { - int32_t width; - int32_t height; - int32_t depth; -} VkExtent3D; - -typedef struct { - VkImageSubresource subresource; - VkOffset3D offset; - VkExtent3D extent; -} VkImageMemoryBindInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkFenceCreateFlags flags; -} VkFenceCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkSemaphoreCreateFlags flags; -} VkSemaphoreCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkEventCreateFlags flags; -} VkEventCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkQueryType queryType; - uint32_t slots; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkQueryPoolCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDeviceSize size; - VkBufferUsageFlags usage; - VkBufferCreateFlags flags; -} VkBufferCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; - VkBufferViewType viewType; - VkFormat format; - VkDeviceSize offset; - VkDeviceSize range; -} VkBufferViewCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkImageType imageType; - VkFormat format; - VkExtent3D extent; - uint32_t mipLevels; - uint32_t arraySize; - uint32_t samples; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkImageCreateFlags flags; -} VkImageCreateInfo; - -typedef struct { - VkDeviceSize offset; - VkDeviceSize size; - VkDeviceSize rowPitch; - VkDeviceSize depthPitch; -} VkSubresourceLayout; - -typedef struct { - VkChannelSwizzle r; - VkChannelSwizzle g; - VkChannelSwizzle b; - VkChannelSwizzle a; -} VkChannelMapping; - -typedef struct { - VkImageAspect aspect; - uint32_t baseMipLevel; - uint32_t mipLevels; - uint32_t baseArraySlice; - uint32_t arraySize; -} VkImageSubresourceRange; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkImage image; - VkImageViewType viewType; - VkFormat format; - VkChannelMapping channels; - VkImageSubresourceRange subresourceRange; -} VkImageViewCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkImage image; - VkFormat format; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - VkImage msaaResolveImage; - VkImageSubresourceRange msaaResolveSubResource; -} VkColorAttachmentViewCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkImage image; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - VkDepthStencilViewCreateFlags flags; -} VkDepthStencilViewCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - size_t codeSize; - const void* pCode; - VkShaderModuleCreateFlags flags; -} VkShaderModuleCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkShaderModule module; - const char* pName; - VkShaderCreateFlags flags; -} VkShaderCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - size_t initialSize; - const void* initialData; - size_t maxSize; -} VkPipelineCacheCreateInfo; - -typedef struct { - uint32_t constantId; - uint32_t offset; -} VkSpecializationMapEntry; - -typedef struct { - uint32_t mapEntryCount; - const VkSpecializationMapEntry* pMap; - const void* pData; -} VkSpecializationInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkShaderStage stage; - VkShader shader; - const VkSpecializationInfo* pSpecializationInfo; -} VkPipelineShaderStageCreateInfo; - -typedef struct { - uint32_t binding; - uint32_t strideInBytes; - VkVertexInputStepRate stepRate; -} VkVertexInputBindingDescription; - -typedef struct { - uint32_t location; - uint32_t binding; - VkFormat format; - uint32_t offsetInBytes; -} VkVertexInputAttributeDescription; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t bindingCount; - const VkVertexInputBindingDescription* pVertexBindingDescriptions; - uint32_t attributeCount; - const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; -} VkPipelineVertexInputStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkPrimitiveTopology topology; - bool32_t primitiveRestartEnable; -} VkPipelineIaStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t patchControlPoints; -} VkPipelineTessStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t viewportCount; -} VkPipelineVpStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - bool32_t depthClipEnable; - bool32_t rasterizerDiscardEnable; - VkFillMode fillMode; - VkCullMode cullMode; - VkFrontFace frontFace; -} VkPipelineRsStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t rasterSamples; - bool32_t sampleShadingEnable; - float minSampleShading; - VkSampleMask sampleMask; -} VkPipelineMsStateCreateInfo; - -typedef struct { - VkStencilOp stencilFailOp; - VkStencilOp stencilPassOp; - VkStencilOp stencilDepthFailOp; - VkCompareOp stencilCompareOp; -} VkStencilOpState; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkFormat format; - bool32_t depthTestEnable; - bool32_t depthWriteEnable; - VkCompareOp depthCompareOp; - bool32_t depthBoundsEnable; - bool32_t stencilTestEnable; - VkStencilOpState front; - VkStencilOpState back; -} VkPipelineDsStateCreateInfo; - -typedef struct { - bool32_t blendEnable; - VkFormat format; - VkBlend srcBlendColor; - VkBlend destBlendColor; - VkBlendOp blendOpColor; - VkBlend srcBlendAlpha; - VkBlend destBlendAlpha; - VkBlendOp blendOpAlpha; - VkChannelFlags channelWriteMask; -} VkPipelineCbAttachmentState; - -typedef struct { - VkStructureType sType; - const void* pNext; - bool32_t alphaToCoverageEnable; - bool32_t logicOpEnable; - VkLogicOp logicOp; - uint32_t attachmentCount; - const VkPipelineCbAttachmentState* pAttachments; -} VkPipelineCbStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const VkPipelineVertexInputStateCreateInfo* pVertexInputState; - const VkPipelineIaStateCreateInfo* pIaState; - const VkPipelineTessStateCreateInfo* pTessState; - const VkPipelineVpStateCreateInfo* pVpState; - const VkPipelineRsStateCreateInfo* pRsState; - const VkPipelineMsStateCreateInfo* pMsState; - const VkPipelineDsStateCreateInfo* pDsState; - const VkPipelineCbStateCreateInfo* pCbState; - VkPipelineCreateFlags flags; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkGraphicsPipelineCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkPipelineShaderStageCreateInfo cs; - VkPipelineCreateFlags flags; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkComputePipelineCreateInfo; - -typedef struct { - VkShaderStageFlags stageFlags; - uint32_t start; - uint32_t length; -} VkPushConstantRange; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t descriptorSetCount; - const VkDescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange* pPushConstantRanges; -} VkPipelineLayoutCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkTexFilter magFilter; - VkTexFilter minFilter; - VkTexMipmapMode mipMode; - VkTexAddress addressU; - VkTexAddress addressV; - VkTexAddress addressW; - float mipLodBias; - uint32_t maxAnisotropy; - bool32_t compareEnable; - VkCompareOp compareOp; - float minLod; - float maxLod; - VkBorderColor borderColor; -} VkSamplerCreateInfo; - -typedef struct { - VkDescriptorType descriptorType; - uint32_t arraySize; - VkShaderStageFlags stageFlags; - const VkSampler* pImmutableSamplers; -} VkDescriptorSetLayoutBinding; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t count; - const VkDescriptorSetLayoutBinding* pBinding; -} VkDescriptorSetLayoutCreateInfo; - -typedef struct { - VkDescriptorType type; - uint32_t count; -} VkDescriptorTypeCount; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t count; - const VkDescriptorTypeCount* pTypeCount; -} VkDescriptorPoolCreateInfo; - -typedef struct { - VkBufferView bufferView; - VkSampler sampler; - VkImageView imageView; - VkImageLayout imageLayout; -} VkDescriptorInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDescriptorSet destSet; - uint32_t destBinding; - uint32_t destArrayElement; - uint32_t count; - VkDescriptorType descriptorType; - const VkDescriptorInfo* pDescriptors; -} VkWriteDescriptorSet; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - VkDescriptorSet destSet; - uint32_t destBinding; - uint32_t destArrayElement; - uint32_t count; -} VkCopyDescriptorSet; - -typedef struct { - float originX; - float originY; - float width; - float height; - float minDepth; - float maxDepth; -} VkViewport; - -typedef struct { - int32_t x; - int32_t y; -} VkOffset2D; - -typedef struct { - int32_t width; - int32_t height; -} VkExtent2D; - -typedef struct { - VkOffset2D offset; - VkExtent2D extent; -} VkRect2D; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t viewportAndScissorCount; - const VkViewport* pViewports; - const VkRect2D* pScissors; -} VkDynamicVpStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float depthBias; - float depthBiasClamp; - float slopeScaledDepthBias; - float lineWidth; -} VkDynamicRsStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float blendConst[4]; -} VkDynamicCbStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float minDepthBounds; - float maxDepthBounds; - uint32_t stencilReadMask; - uint32_t stencilWriteMask; - uint32_t stencilFrontRef; - uint32_t stencilBackRef; -} VkDynamicDsStateCreateInfo; - -typedef struct { - VkColorAttachmentView view; - VkImageLayout layout; -} VkColorAttachmentBindInfo; - -typedef struct { - VkDepthStencilView view; - VkImageLayout layout; -} VkDepthStencilBindInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t colorAttachmentCount; - const VkColorAttachmentBindInfo* pColorAttachments; - const VkDepthStencilBindInfo* pDepthStencilAttachment; - uint32_t sampleCount; - uint32_t width; - uint32_t height; - uint32_t layers; -} VkFramebufferCreateInfo; - -typedef union { - float f32[4]; - int32_t s32[4]; - uint32_t u32[4]; -} VkClearColorValue; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkRect2D renderArea; - uint32_t colorAttachmentCount; - VkExtent2D extent; - uint32_t sampleCount; - uint32_t layers; - const VkFormat* pColorFormats; - const VkImageLayout* pColorLayouts; - const VkAttachmentLoadOp* pColorLoadOps; - const VkAttachmentStoreOp* pColorStoreOps; - const VkClearColorValue* pColorLoadClearValues; - VkFormat depthStencilFormat; - VkImageLayout depthStencilLayout; - VkAttachmentLoadOp depthLoadOp; - float depthLoadClearValue; - VkAttachmentStoreOp depthStoreOp; - VkAttachmentLoadOp stencilLoadOp; - uint32_t stencilLoadClearValue; - VkAttachmentStoreOp stencilStoreOp; -} VkRenderPassCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t queueNodeIndex; - VkCmdBufferLevel level; - VkCmdBufferCreateFlags flags; -} VkCmdBufferCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkCmdBufferOptimizeFlags flags; - VkRenderPass renderPass; - VkFramebuffer framebuffer; -} VkCmdBufferBeginInfo; - -typedef struct { - VkDeviceSize srcOffset; - VkDeviceSize destOffset; - VkDeviceSize copySize; -} VkBufferCopy; - -typedef struct { - VkImageSubresource srcSubresource; - VkOffset3D srcOffset; - VkImageSubresource destSubresource; - VkOffset3D destOffset; - VkExtent3D extent; -} VkImageCopy; - -typedef struct { - VkImageSubresource srcSubresource; - VkOffset3D srcOffset; - VkExtent3D srcExtent; - VkImageSubresource destSubresource; - VkOffset3D destOffset; - VkExtent3D destExtent; -} VkImageBlit; - -typedef struct { - VkDeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresource imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy; - -typedef struct { - VkOffset3D offset; - VkExtent3D extent; -} VkRect3D; - -typedef struct { - VkImageSubresource srcSubresource; - VkOffset3D srcOffset; - VkImageSubresource destSubresource; - VkOffset3D destOffset; - VkExtent3D extent; -} VkImageResolve; - -typedef struct { - VkRenderPass renderPass; - VkFramebuffer framebuffer; - VkRenderPassContents contents; -} VkRenderPassBegin; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkMemoryOutputFlags outputMask; - VkMemoryInputFlags inputMask; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; -} VkBufferMemoryBarrier; - -typedef struct { - uint32_t x; - uint32_t y; - uint32_t z; -} VkDispatchIndirectCmd; - -typedef struct { - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VkDrawIndexedIndirectCmd; - -typedef struct { - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; -} VkDrawIndirectCmd; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkMemoryOutputFlags outputMask; - VkMemoryInputFlags inputMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - VkImage image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t layerCount; - const char *const* ppActiveLayerNames; -} VkLayerCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkMemoryOutputFlags outputMask; - VkMemoryInputFlags inputMask; -} VkMemoryBarrier; - - -typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); -typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); -typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatInfo)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatInfo); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLimits)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueCount)(VkPhysicalDevice physicalDevice, uint32_t* pCount); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueProperties)(VkPhysicalDevice physicalDevice, uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperies); -typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); -typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); -typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); -typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device); -typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionCount)(uint32_t* pCount); -typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionProperties)(uint32_t extensionIndex, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionCount)(VkPhysicalDevice physicalDevice, uint32_t* pCount); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, uint32_t extensionIndex, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalDevice physicalDevice, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved); -typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue); -typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence); -typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); -typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); -typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); -typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem); -typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); -typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem); -typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); -typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); -typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkDevice device, VkObjectType objType, VkObject object); -typedef VkResult (VKAPI *PFN_vkBindObjectMemory)(VkDevice device, VkObjectType objType, VkObject object, VkDeviceMemory mem, VkDeviceSize memOffset); -typedef VkResult (VKAPI *PFN_vkGetObjectMemoryRequirements)(VkDevice device, VkObjectType objType, VkObject object, VkMemoryRequirements* pMemoryRequirements); -typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset); -typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset); -typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); -typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); -typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); -typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout); -typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore); -typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore); -typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore); -typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent); -typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); -typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); -typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); -typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); -typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage); -typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); -typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); -typedef VkResult (VKAPI *PFN_vkCreateColorAttachmentView)(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView); -typedef VkResult (VKAPI *PFN_vkCreateDepthStencilView)(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView); -typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule); -typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); -typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache); -typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache); -typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData); -typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); -typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); -typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); -typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); -typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); -typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); -typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); -typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); -typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount); -typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); -typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState); -typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); -typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); -typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); -typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer); -typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo); -typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); -typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer); -typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef void (VKAPI *PFN_vkCmdBindDynamicStateObject)(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject dynamicState); -typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); -typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); -typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); -typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); -typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); -typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); -typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); -typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); -typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset); -typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter); -typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData); -typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data); -typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI *PFN_vkCmdClearColorAttachment)(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects); -typedef void (VKAPI *PFN_vkCmdClearDepthStencilAttachment)(VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, const VkRect3D* pRects); -typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); -typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent); -typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent); -typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, VkPipeEventFlags pipeEventMask, uint32_t memBarrierCount, const void* const* ppMemBarriers); -typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, VkPipeEventFlags pipeEventMask, uint32_t memBarrierCount, const void* const* ppMemBarriers); -typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); -typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot); -typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); -typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset); -typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags); -typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values); -typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin); -typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer); -typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers); - -#ifdef VK_PROTOTYPES -VkResult VKAPI vkCreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - VkInstance* pInstance); - -VkResult VKAPI vkDestroyInstance( - VkInstance instance); - -VkResult VKAPI vkEnumeratePhysicalDevices( - VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices); - -VkResult VKAPI vkGetPhysicalDeviceFeatures( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures); - -VkResult VKAPI vkGetPhysicalDeviceFormatInfo( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties* pFormatInfo); - -VkResult VKAPI vkGetPhysicalDeviceLimits( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceLimits* pLimits); - -VkResult VKAPI vkGetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties); - -VkResult VKAPI vkGetPhysicalDeviceQueueCount( - VkPhysicalDevice physicalDevice, - uint32_t* pCount); - -VkResult VKAPI vkGetPhysicalDeviceQueueProperties( - VkPhysicalDevice physicalDevice, - uint32_t count, - VkPhysicalDeviceQueueProperties* pQueueProperties); - -VkResult VKAPI vkGetPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperies); - -PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr( - VkInstance instance, - const char* pName); - -PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( - VkDevice device, - const char* pName); - -VkResult VKAPI vkCreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - VkDevice* pDevice); - -VkResult VKAPI vkDestroyDevice( - VkDevice device); - -VkResult VKAPI vkGetGlobalExtensionCount( - uint32_t* pCount); - -VkResult VKAPI vkGetGlobalExtensionProperties( - uint32_t extensionIndex, - VkExtensionProperties* pProperties); - -VkResult VKAPI vkGetPhysicalDeviceExtensionCount( - VkPhysicalDevice physicalDevice, - uint32_t* pCount); - -VkResult VKAPI vkGetPhysicalDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - uint32_t extensionIndex, - VkExtensionProperties* pProperties); - -VkResult VKAPI vkEnumerateLayers( - VkPhysicalDevice physicalDevice, - size_t maxStringSize, - size_t* pLayerCount, - char* const* pOutLayers, - void* pReserved); - -VkResult VKAPI vkGetDeviceQueue( - VkDevice device, - uint32_t queueNodeIndex, - uint32_t queueIndex, - VkQueue* pQueue); - -VkResult VKAPI vkQueueSubmit( - VkQueue queue, - uint32_t cmdBufferCount, - const VkCmdBuffer* pCmdBuffers, - VkFence fence); - -VkResult VKAPI vkQueueWaitIdle( - VkQueue queue); - -VkResult VKAPI vkDeviceWaitIdle( - VkDevice device); - -VkResult VKAPI vkAllocMemory( - VkDevice device, - const VkMemoryAllocInfo* pAllocInfo, - VkDeviceMemory* pMem); - -VkResult VKAPI vkFreeMemory( - VkDevice device, - VkDeviceMemory mem); - -VkResult VKAPI vkMapMemory( - VkDevice device, - VkDeviceMemory mem, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData); - -VkResult VKAPI vkUnmapMemory( - VkDevice device, - VkDeviceMemory mem); - -VkResult VKAPI vkFlushMappedMemoryRanges( - VkDevice device, - uint32_t memRangeCount, - const VkMappedMemoryRange* pMemRanges); - -VkResult VKAPI vkInvalidateMappedMemoryRanges( - VkDevice device, - uint32_t memRangeCount, - const VkMappedMemoryRange* pMemRanges); - -VkResult VKAPI vkDestroyObject( - VkDevice device, - VkObjectType objType, - VkObject object); - -VkResult VKAPI vkBindObjectMemory( - VkDevice device, - VkObjectType objType, - VkObject object, - VkDeviceMemory mem, - VkDeviceSize memOffset); - -VkResult VKAPI vkGetObjectMemoryRequirements( - VkDevice device, - VkObjectType objType, - VkObject object, - VkMemoryRequirements* pMemoryRequirements); - -VkResult VKAPI vkQueueBindSparseBufferMemory( - VkQueue queue, - VkBuffer buffer, - VkDeviceSize rangeOffset, - VkDeviceSize rangeSize, - VkDeviceMemory mem, - VkDeviceSize memOffset); - -VkResult VKAPI vkQueueBindSparseImageMemory( - VkQueue queue, - VkImage image, - const VkImageMemoryBindInfo* pBindInfo, - VkDeviceMemory mem, - VkDeviceSize memOffset); - -VkResult VKAPI vkCreateFence( - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - VkFence* pFence); - -VkResult VKAPI vkResetFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences); - -VkResult VKAPI vkGetFenceStatus( - VkDevice device, - VkFence fence); - -VkResult VKAPI vkWaitForFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences, - bool32_t waitAll, - uint64_t timeout); - -VkResult VKAPI vkCreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - VkSemaphore* pSemaphore); - -VkResult VKAPI vkQueueSignalSemaphore( - VkQueue queue, - VkSemaphore semaphore); - -VkResult VKAPI vkQueueWaitSemaphore( - VkQueue queue, - VkSemaphore semaphore); - -VkResult VKAPI vkCreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - VkEvent* pEvent); - -VkResult VKAPI vkGetEventStatus( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkSetEvent( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkResetEvent( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkCreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - VkQueryPool* pQueryPool); - -VkResult VKAPI vkGetQueryPoolResults( - VkDevice device, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount, - size_t* pDataSize, - void* pData, - VkQueryResultFlags flags); - -VkResult VKAPI vkCreateBuffer( - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - VkBuffer* pBuffer); - -VkResult VKAPI vkCreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - VkBufferView* pView); - -VkResult VKAPI vkCreateImage( - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - VkImage* pImage); - -VkResult VKAPI vkGetImageSubresourceLayout( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout); - -VkResult VKAPI vkCreateImageView( - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - VkImageView* pView); - -VkResult VKAPI vkCreateColorAttachmentView( - VkDevice device, - const VkColorAttachmentViewCreateInfo* pCreateInfo, - VkColorAttachmentView* pView); - -VkResult VKAPI vkCreateDepthStencilView( - VkDevice device, - const VkDepthStencilViewCreateInfo* pCreateInfo, - VkDepthStencilView* pView); - -VkResult VKAPI vkCreateShaderModule( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - VkShaderModule* pShaderModule); - -VkResult VKAPI vkCreateShader( - VkDevice device, - const VkShaderCreateInfo* pCreateInfo, - VkShader* pShader); - -VkResult VKAPI vkCreatePipelineCache( - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - VkPipelineCache* pPipelineCache); - -size_t VKAPI vkGetPipelineCacheSize( - VkDevice device, - VkPipelineCache pipelineCache); - -VkResult VKAPI vkGetPipelineCacheData( - VkDevice device, - VkPipelineCache pipelineCache, - void* pData); - -VkResult VKAPI vkMergePipelineCaches( - VkDevice device, - VkPipelineCache destCache, - uint32_t srcCacheCount, - const VkPipelineCache* pSrcCaches); - -VkResult VKAPI vkCreateGraphicsPipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t count, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - VkPipeline* pPipelines); - -VkResult VKAPI vkCreateComputePipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t count, - const VkComputePipelineCreateInfo* pCreateInfos, - VkPipeline* pPipelines); - -VkResult VKAPI vkCreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - VkPipelineLayout* pPipelineLayout); - -VkResult VKAPI vkCreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - VkSampler* pSampler); - -VkResult VKAPI vkCreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayout* pSetLayout); - -VkResult VKAPI vkCreateDescriptorPool( - VkDevice device, - VkDescriptorPoolUsage poolUsage, - uint32_t maxSets, - const VkDescriptorPoolCreateInfo* pCreateInfo, - VkDescriptorPool* pDescriptorPool); - -VkResult VKAPI vkResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool); - -VkResult VKAPI vkAllocDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorSetUsage setUsage, - uint32_t count, - const VkDescriptorSetLayout* pSetLayouts, - VkDescriptorSet* pDescriptorSets, - uint32_t* pCount); - -VkResult VKAPI vkUpdateDescriptorSets( - VkDevice device, - uint32_t writeCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t copyCount, - const VkCopyDescriptorSet* pDescriptorCopies); - -VkResult VKAPI vkCreateDynamicViewportState( - VkDevice device, - const VkDynamicVpStateCreateInfo* pCreateInfo, - VkDynamicVpState* pState); - -VkResult VKAPI vkCreateDynamicRasterState( - VkDevice device, - const VkDynamicRsStateCreateInfo* pCreateInfo, - VkDynamicRsState* pState); - -VkResult VKAPI vkCreateDynamicColorBlendState( - VkDevice device, - const VkDynamicCbStateCreateInfo* pCreateInfo, - VkDynamicCbState* pState); - -VkResult VKAPI vkCreateDynamicDepthStencilState( - VkDevice device, - const VkDynamicDsStateCreateInfo* pCreateInfo, - VkDynamicDsState* pState); - -VkResult VKAPI vkCreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - VkFramebuffer* pFramebuffer); - -VkResult VKAPI vkCreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - VkRenderPass* pRenderPass); - -VkResult VKAPI vkGetRenderAreaGranularity( - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity); - -VkResult VKAPI vkCreateCommandBuffer( - VkDevice device, - const VkCmdBufferCreateInfo* pCreateInfo, - VkCmdBuffer* pCmdBuffer); - -VkResult VKAPI vkBeginCommandBuffer( - VkCmdBuffer cmdBuffer, - const VkCmdBufferBeginInfo* pBeginInfo); - -VkResult VKAPI vkEndCommandBuffer( - VkCmdBuffer cmdBuffer); - -VkResult VKAPI vkResetCommandBuffer( - VkCmdBuffer cmdBuffer); - -void VKAPI vkCmdBindPipeline( - VkCmdBuffer cmdBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); - -void VKAPI vkCmdBindDynamicStateObject( - VkCmdBuffer cmdBuffer, - VkStateBindPoint stateBindPoint, - VkDynamicStateObject dynamicState); - -void VKAPI vkCmdBindDescriptorSets( - VkCmdBuffer cmdBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t setCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets); - -void VKAPI vkCmdBindIndexBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType); - -void VKAPI vkCmdBindVertexBuffers( - VkCmdBuffer cmdBuffer, - uint32_t startBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets); - -void VKAPI vkCmdDraw( - VkCmdBuffer cmdBuffer, - uint32_t firstVertex, - uint32_t vertexCount, - uint32_t firstInstance, - uint32_t instanceCount); - -void VKAPI vkCmdDrawIndexed( - VkCmdBuffer cmdBuffer, - uint32_t firstIndex, - uint32_t indexCount, - int32_t vertexOffset, - uint32_t firstInstance, - uint32_t instanceCount); - -void VKAPI vkCmdDrawIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDrawIndexedIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDispatch( - VkCmdBuffer cmdBuffer, - uint32_t x, - uint32_t y, - uint32_t z); - -void VKAPI vkCmdDispatchIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset); - -void VKAPI vkCmdCopyBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer srcBuffer, - VkBuffer destBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions); - -void VKAPI vkCmdCopyImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions); - -void VKAPI vkCmdBlitImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions, - VkTexFilter filter); - -void VKAPI vkCmdCopyBufferToImage( - VkCmdBuffer cmdBuffer, - VkBuffer srcBuffer, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -void VKAPI vkCmdCopyImageToBuffer( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer destBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -void VKAPI vkCmdUpdateBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize dataSize, - const uint32_t* pData); - -void VKAPI vkCmdFillBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize fillSize, - uint32_t data); - -void VKAPI vkCmdClearColorImage( - VkCmdBuffer cmdBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -void VKAPI vkCmdClearDepthStencilImage( - VkCmdBuffer cmdBuffer, - VkImage image, - VkImageLayout imageLayout, - float depth, - uint32_t stencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -void VKAPI vkCmdClearColorAttachment( - VkCmdBuffer cmdBuffer, - uint32_t colorAttachment, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rectCount, - const VkRect3D* pRects); - -void VKAPI vkCmdClearDepthStencilAttachment( - VkCmdBuffer cmdBuffer, - VkImageAspectFlags imageAspectMask, - VkImageLayout imageLayout, - float depth, - uint32_t stencil, - uint32_t rectCount, - const VkRect3D* pRects); - -void VKAPI vkCmdResolveImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions); - -void VKAPI vkCmdSetEvent( - VkCmdBuffer cmdBuffer, - VkEvent event, - VkPipeEvent pipeEvent); - -void VKAPI vkCmdResetEvent( - VkCmdBuffer cmdBuffer, - VkEvent event, - VkPipeEvent pipeEvent); - -void VKAPI vkCmdWaitEvents( - VkCmdBuffer cmdBuffer, - VkWaitEvent waitEvent, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipeEventFlags pipeEventMask, - uint32_t memBarrierCount, - const void* const* ppMemBarriers); - -void VKAPI vkCmdPipelineBarrier( - VkCmdBuffer cmdBuffer, - VkWaitEvent waitEvent, - VkPipeEventFlags pipeEventMask, - uint32_t memBarrierCount, - const void* const* ppMemBarriers); - -void VKAPI vkCmdBeginQuery( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t slot, - VkQueryControlFlags flags); - -void VKAPI vkCmdEndQuery( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t slot); - -void VKAPI vkCmdResetQueryPool( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount); - -void VKAPI vkCmdWriteTimestamp( - VkCmdBuffer cmdBuffer, - VkTimestampType timestampType, - VkBuffer destBuffer, - VkDeviceSize destOffset); - -void VKAPI vkCmdCopyQueryPoolResults( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize destStride, - VkQueryResultFlags flags); - -void VKAPI vkCmdPushConstants( - VkCmdBuffer cmdBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t start, - uint32_t length, - const void* values); - -void VKAPI vkCmdBeginRenderPass( - VkCmdBuffer cmdBuffer, - const VkRenderPassBegin* pRenderPassBegin); - -void VKAPI vkCmdEndRenderPass( - VkCmdBuffer cmdBuffer); - -void VKAPI vkCmdExecuteCommands( - VkCmdBuffer cmdBuffer, - uint32_t cmdBuffersCount, - const VkCmdBuffer* pCmdBuffers); -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/vulkan/vulkan-90.h b/include/vulkan/vulkan-90.h deleted file mode 100644 index 8e8cb917ce2..00000000000 --- a/include/vulkan/vulkan-90.h +++ /dev/null @@ -1,2894 +0,0 @@ -#ifndef __vulkan_h_ -#define __vulkan_h_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015 The Khronos Group Inc. -** -** Permission is hereby granted, free of charge, to any person obtaining a -** copy of this software and/or associated documentation files (the -** "Materials"), to deal in the Materials without restriction, including -** without limitation the rights to use, copy, modify, merge, publish, -** distribute, sublicense, and/or sell copies of the Materials, and to -** permit persons to whom the Materials are furnished to do so, subject to -** the following conditions: -** -** The above copyright notice and this permission notice shall be included -** in all copies or substantial portions of the Materials. -** -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. -*/ - - -#include "vk_platform.h" - -#define VK_MAKE_VERSION(major, minor, patch) \ - ((major << 22) | (minor << 12) | patch) - -// Vulkan API version supported by this file -#define VK_API_VERSION VK_MAKE_VERSION(0, 90, 0) - -#if defined (__cplusplus) && (VK_UINTPTRLEAST64_MAX == UINTPTR_MAX) - #define VK_TYPE_SAFE_COMPATIBLE_HANDLES 1 -#endif - -#if defined(VK_TYPE_SAFE_COMPATIBLE_HANDLES) && !defined(VK_DISABLE_TYPE_SAFE_HANDLES) - #define VK_DEFINE_PTR_HANDLE(_obj) struct _obj##_T { char _dummy; }; typedef _obj##_T* _obj; - #define VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj; - - #define VK_DEFINE_BASE_HANDLE(_obj) VK_DEFINE_PTR_HANDLE(_obj) - #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) - #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) -#else - #define VK_DEFINE_BASE_HANDLE(_obj) typedef VkUintPtrLeast64 _obj; - #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) typedef uintptr_t _obj; - #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) typedef VkUintPtrLeast64 _obj; -#endif - - -#define VK_MAX_PHYSICAL_DEVICE_NAME 256 -#define VK_MAX_EXTENSION_NAME 256 -#define VK_LOD_CLAMP_NONE MAX_FLOAT -#define VK_WHOLE_SIZE UINT64_MAX -#define VK_TRUE 1 -#define VK_FALSE 0 -#define VK_NULL_HANDLE 0 - -VK_DEFINE_BASE_HANDLE(VkObject) -VK_DEFINE_DISP_SUBCLASS_HANDLE(VkInstance, VkObject) -VK_DEFINE_DISP_SUBCLASS_HANDLE(VkPhysicalDevice, VkObject) -VK_DEFINE_DISP_SUBCLASS_HANDLE(VkDevice, VkObject) -VK_DEFINE_DISP_SUBCLASS_HANDLE(VkQueue, VkObject) -VK_DEFINE_DISP_SUBCLASS_HANDLE(VkCmdBuffer, VkObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkNonDispatchable, VkObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDeviceMemory, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBuffer, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBufferView, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImage, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImageView, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkColorAttachmentView, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDepthStencilView, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShader, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipeline, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineLayout, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSampler, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSet, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSetLayout, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorPool, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicStateObject, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicVpState, VkDynamicStateObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicRsState, VkDynamicStateObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicCbState, VkDynamicStateObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicDsState, VkDynamicStateObject) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFence, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSemaphore, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkEvent, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkQueryPool, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFramebuffer, VkNonDispatchable) -VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable) - -// This macro defines INT_MAX in enumerations to force compilers to use 32 bits -// to represent them. This may or may not be necessary on some compilers. The -// option to compile it out may allow compilers that warn about missing enumerants -// in switch statements to be silenced. -// Using this macro is not needed for flag bit enums because those aren't used -// as storage type anywhere. -#define VK_MAX_ENUM(Prefix) VK_##Prefix##_MAX_ENUM = 0x7FFFFFFF - -// This macro defines the BEGIN_RANGE, END_RANGE, NUM, and MAX_ENUM constants for -// the enumerations. -#define VK_ENUM_RANGE(Prefix, First, Last) \ - VK_##Prefix##_BEGIN_RANGE = VK_##Prefix##_##First, \ - VK_##Prefix##_END_RANGE = VK_##Prefix##_##Last, \ - VK_NUM_##Prefix = (VK_##Prefix##_END_RANGE - VK_##Prefix##_BEGIN_RANGE + 1), \ - VK_MAX_ENUM(Prefix) - -// This is a helper macro to define the value of flag bit enum values. -#define VK_BIT(bit) (1 << (bit)) - -// ------------------------------------------------------------------------------------------------ -// Enumerations - -typedef enum VkMemoryPriority_ -{ - VK_MEMORY_PRIORITY_UNUSED = 0x00000000, - VK_MEMORY_PRIORITY_VERY_LOW = 0x00000001, - VK_MEMORY_PRIORITY_LOW = 0x00000002, - VK_MEMORY_PRIORITY_NORMAL = 0x00000003, - VK_MEMORY_PRIORITY_HIGH = 0x00000004, - VK_MEMORY_PRIORITY_VERY_HIGH = 0x00000005, - - VK_ENUM_RANGE(MEMORY_PRIORITY, UNUSED, VERY_HIGH) -} VkMemoryPriority; - -typedef enum VkImageLayout_ -{ - VK_IMAGE_LAYOUT_UNDEFINED = 0x00000000, // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation) - VK_IMAGE_LAYOUT_GENERAL = 0x00000001, // General layout when image can be used for any kind of access - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 0x00000002, // Optimal layout when image is only used for color attachment read/write - VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003, // Optimal layout when image is only used for depth/stencil attachment read/write - VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004, // Optimal layout when image is used for read only depth/stencil attachment and shader access - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005, // Optimal layout when image is used for read only shader access - VK_IMAGE_LAYOUT_CLEAR_OPTIMAL = 0x00000006, // Optimal layout when image is used only for clear operations - VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000007, // Optimal layout when image is used only as source of transfer operations - VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000008, // Optimal layout when image is used only as destination of transfer operations - - VK_ENUM_RANGE(IMAGE_LAYOUT, UNDEFINED, TRANSFER_DESTINATION_OPTIMAL) -} VkImageLayout; - -typedef enum VkPipeEvent_ -{ - VK_PIPE_EVENT_TOP_OF_PIPE = 0x00000001, // Set event before the device starts processing subsequent command - VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE = 0x00000002, // Set event when all pending vertex processing is complete - VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE = 0x00000003, // Set event when all pending fragment shader executions are complete, within each fragment location - VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE = 0x00000004, // Set event when all pending fragment shader executions are complete - VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE = 0x00000005, // Set event when all pending graphics operations are complete - VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE = 0x00000006, // Set event when all pending compute operations are complete - VK_PIPE_EVENT_TRANSFER_COMPLETE = 0x00000007, // Set event when all pending transfer operations are complete - VK_PIPE_EVENT_COMMANDS_COMPLETE = 0x00000008, // Set event when all pending work is complete - - VK_ENUM_RANGE(PIPE_EVENT, TOP_OF_PIPE, COMMANDS_COMPLETE) -} VkPipeEvent; - -typedef enum VkWaitEvent_ -{ - VK_WAIT_EVENT_TOP_OF_PIPE = 0x00000001, // Wait event before the device starts processing subsequent commands - VK_WAIT_EVENT_BEFORE_RASTERIZATION = 0x00000002, // Wait event before rasterizing subsequent primitives - - VK_ENUM_RANGE(WAIT_EVENT, TOP_OF_PIPE, BEFORE_RASTERIZATION) -} VkWaitEvent; - -typedef enum VkAttachmentLoadOp_ -{ - VK_ATTACHMENT_LOAD_OP_LOAD = 0x00000000, - VK_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001, - VK_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002, - - VK_ENUM_RANGE(ATTACHMENT_LOAD_OP, LOAD, DONT_CARE) -} VkAttachmentLoadOp; - -typedef enum VkAttachmentStoreOp_ -{ - VK_ATTACHMENT_STORE_OP_STORE = 0x00000000, - VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 0x00000001, - VK_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000002, - - VK_ENUM_RANGE(ATTACHMENT_STORE_OP, STORE, DONT_CARE) -} VkAttachmentStoreOp; - -typedef enum VkImageType_ -{ - VK_IMAGE_TYPE_1D = 0x00000000, - VK_IMAGE_TYPE_2D = 0x00000001, - VK_IMAGE_TYPE_3D = 0x00000002, - - VK_ENUM_RANGE(IMAGE_TYPE, 1D, 3D) -} VkImageType; - -typedef enum VkImageTiling_ -{ - VK_IMAGE_TILING_LINEAR = 0x00000000, - VK_IMAGE_TILING_OPTIMAL = 0x00000001, - - VK_ENUM_RANGE(IMAGE_TILING, LINEAR, OPTIMAL) -} VkImageTiling; - -typedef enum VkImageViewType_ -{ - VK_IMAGE_VIEW_TYPE_1D = 0x00000000, - VK_IMAGE_VIEW_TYPE_2D = 0x00000001, - VK_IMAGE_VIEW_TYPE_3D = 0x00000002, - VK_IMAGE_VIEW_TYPE_CUBE = 0x00000003, - - VK_ENUM_RANGE(IMAGE_VIEW_TYPE, 1D, CUBE) -} VkImageViewType; - -typedef enum VkImageAspect_ -{ - VK_IMAGE_ASPECT_COLOR = 0x00000000, - VK_IMAGE_ASPECT_DEPTH = 0x00000001, - VK_IMAGE_ASPECT_STENCIL = 0x00000002, - - VK_ENUM_RANGE(IMAGE_ASPECT, COLOR, STENCIL) -} VkImageAspect; - -typedef enum VkBufferViewType_ -{ - VK_BUFFER_VIEW_TYPE_RAW = 0x00000000, // Raw buffer without special structure (UBO, SSBO) - VK_BUFFER_VIEW_TYPE_FORMATTED = 0x00000001, // Buffer with format (TBO, IBO) - - VK_ENUM_RANGE(BUFFER_VIEW_TYPE, RAW, FORMATTED) -} VkBufferViewType; - -typedef enum VkChannelSwizzle_ -{ - VK_CHANNEL_SWIZZLE_ZERO = 0x00000000, - VK_CHANNEL_SWIZZLE_ONE = 0x00000001, - VK_CHANNEL_SWIZZLE_R = 0x00000002, - VK_CHANNEL_SWIZZLE_G = 0x00000003, - VK_CHANNEL_SWIZZLE_B = 0x00000004, - VK_CHANNEL_SWIZZLE_A = 0x00000005, - - VK_ENUM_RANGE(CHANNEL_SWIZZLE, ZERO, A) -} VkChannelSwizzle; - -typedef enum VkDescriptorType_ -{ - VK_DESCRIPTOR_TYPE_SAMPLER = 0x00000000, - VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 0x00000001, - VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 0x00000002, - VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 0x00000003, - VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 0x00000004, - VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 0x00000005, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 0x00000006, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 0x00000007, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000008, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 0x00000009, - - VK_ENUM_RANGE(DESCRIPTOR_TYPE, SAMPLER, STORAGE_BUFFER_DYNAMIC) -} VkDescriptorType; - -typedef enum VkDescriptorPoolUsage_ -{ - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0x00000000, - VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 0x00000001, - - VK_ENUM_RANGE(DESCRIPTOR_POOL_USAGE, ONE_SHOT, DYNAMIC) -} VkDescriptorPoolUsage; - -typedef enum VkDescriptorUpdateMode_ -{ - VK_DESCRIPTOR_UPDATE_MODE_COPY = 0x00000000, - VK_DESCRIPTOR_UPDATE_MODE_FASTEST = 0x00000001, - - VK_ENUM_RANGE(DESCRIPTOR_UPDATE_MODE, COPY, FASTEST) -} VkDescriptorUpdateMode; - -typedef enum VkDescriptorSetUsage_ -{ - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000, - VK_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001, - - VK_ENUM_RANGE(DESCRIPTOR_SET_USAGE, ONE_SHOT, STATIC) -} VkDescriptorSetUsage; - -typedef enum VkQueryType_ -{ - VK_QUERY_TYPE_OCCLUSION = 0x00000000, - VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001, // Optional - - VK_ENUM_RANGE(QUERY_TYPE, OCCLUSION, PIPELINE_STATISTICS) -} VkQueryType; - -typedef enum VkTimestampType_ -{ - VK_TIMESTAMP_TYPE_TOP = 0x00000000, - VK_TIMESTAMP_TYPE_BOTTOM = 0x00000001, - - VK_ENUM_RANGE(TIMESTAMP_TYPE, TOP, BOTTOM) -} VkTimestampType; - -typedef enum VkBorderColor_ -{ - VK_BORDER_COLOR_OPAQUE_WHITE = 0x00000000, - VK_BORDER_COLOR_TRANSPARENT_BLACK = 0x00000001, - VK_BORDER_COLOR_OPAQUE_BLACK = 0x00000002, - - VK_ENUM_RANGE(BORDER_COLOR, OPAQUE_WHITE, OPAQUE_BLACK) -} VkBorderColor; - -typedef enum VkPipelineBindPoint_ -{ - VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000000, - VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001, - - VK_ENUM_RANGE(PIPELINE_BIND_POINT, COMPUTE, GRAPHICS) -} VkPipelineBindPoint; - -typedef enum VkStateBindPoint_ -{ - VK_STATE_BIND_POINT_VIEWPORT = 0x00000000, - VK_STATE_BIND_POINT_RASTER = 0x00000001, - VK_STATE_BIND_POINT_COLOR_BLEND = 0x00000002, - VK_STATE_BIND_POINT_DEPTH_STENCIL = 0x00000003, - - VK_ENUM_RANGE(STATE_BIND_POINT, VIEWPORT, DEPTH_STENCIL) -} VkStateBindPoint; - -typedef enum VkPrimitiveTopology_ -{ - VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0x00000000, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 0x00000001, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 0x00000002, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 0x00000003, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 0x00000004, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 0x00000005, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 0x00000006, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009, - VK_PRIMITIVE_TOPOLOGY_PATCH = 0x0000000a, - - VK_ENUM_RANGE(PRIMITIVE_TOPOLOGY, POINT_LIST, PATCH) -} VkPrimitiveTopology; - -typedef enum VkIndexType_ -{ - VK_INDEX_TYPE_UINT8 = 0x00000000, - VK_INDEX_TYPE_UINT16 = 0x00000001, - VK_INDEX_TYPE_UINT32 = 0x00000002, - - VK_ENUM_RANGE(INDEX_TYPE, UINT8, UINT32) -} VkIndexType; - -typedef enum VkTexFilter_ -{ - VK_TEX_FILTER_NEAREST = 0x00000000, - VK_TEX_FILTER_LINEAR = 0x00000001, - - VK_ENUM_RANGE(TEX_FILTER, NEAREST, LINEAR) -} VkTexFilter; - -typedef enum VkTexMipmapMode_ -{ - VK_TEX_MIPMAP_MODE_BASE = 0x00000000, // Always choose base level - VK_TEX_MIPMAP_MODE_NEAREST = 0x00000001, // Choose nearest mip level - VK_TEX_MIPMAP_MODE_LINEAR = 0x00000002, // Linear filter between mip levels - - VK_ENUM_RANGE(TEX_MIPMAP_MODE, BASE, LINEAR) -} VkTexMipmapMode; - -typedef enum VkTexAddress_ -{ - VK_TEX_ADDRESS_WRAP = 0x00000000, - VK_TEX_ADDRESS_MIRROR = 0x00000001, - VK_TEX_ADDRESS_CLAMP = 0x00000002, - VK_TEX_ADDRESS_MIRROR_ONCE = 0x00000003, - VK_TEX_ADDRESS_CLAMP_BORDER = 0x00000004, - - VK_ENUM_RANGE(TEX_ADDRESS, WRAP, CLAMP_BORDER) -} VkTexAddress; - -typedef enum VkCompareOp_ -{ - VK_COMPARE_OP_NEVER = 0x00000000, - VK_COMPARE_OP_LESS = 0x00000001, - VK_COMPARE_OP_EQUAL = 0x00000002, - VK_COMPARE_OP_LESS_EQUAL = 0x00000003, - VK_COMPARE_OP_GREATER = 0x00000004, - VK_COMPARE_OP_NOT_EQUAL = 0x00000005, - VK_COMPARE_OP_GREATER_EQUAL = 0x00000006, - VK_COMPARE_OP_ALWAYS = 0x00000007, - - VK_ENUM_RANGE(COMPARE_OP, NEVER, ALWAYS) -} VkCompareOp; - -typedef enum VkFillMode_ -{ - VK_FILL_MODE_POINTS = 0x00000000, - VK_FILL_MODE_WIREFRAME = 0x00000001, - VK_FILL_MODE_SOLID = 0x00000002, - - VK_ENUM_RANGE(FILL_MODE, POINTS, SOLID) -} VkFillMode; - -typedef enum VkCullMode_ -{ - VK_CULL_MODE_NONE = 0x00000000, - VK_CULL_MODE_FRONT = 0x00000001, - VK_CULL_MODE_BACK = 0x00000002, - VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, - - VK_ENUM_RANGE(CULL_MODE, NONE, FRONT_AND_BACK) -} VkCullMode; - -typedef enum VkFrontFace_ -{ - VK_FRONT_FACE_CCW = 0x00000000, - VK_FRONT_FACE_CW = 0x00000001, - - VK_ENUM_RANGE(FRONT_FACE, CCW, CW) -} VkFrontFace; - -typedef enum VkProvokingVertex_ -{ - VK_PROVOKING_VERTEX_FIRST = 0x00000000, - VK_PROVOKING_VERTEX_LAST = 0x00000001, - - VK_ENUM_RANGE(PROVOKING_VERTEX, FIRST, LAST) -} VkProvokingVertex; - -typedef enum VkCoordinateOrigin_ -{ - VK_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000, - VK_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001, - - VK_ENUM_RANGE(COORDINATE_ORIGIN, UPPER_LEFT, LOWER_LEFT) -} VkCoordinateOrigin; - -typedef enum VkDepthMode_ -{ - VK_DEPTH_MODE_ZERO_TO_ONE = 0x00000000, - VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE = 0x00000001, - - VK_ENUM_RANGE(DEPTH_MODE, ZERO_TO_ONE, NEGATIVE_ONE_TO_ONE) -} VkDepthMode; - -typedef enum VkBlend_ -{ - VK_BLEND_ZERO = 0x00000000, - VK_BLEND_ONE = 0x00000001, - VK_BLEND_SRC_COLOR = 0x00000002, - VK_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003, - VK_BLEND_DEST_COLOR = 0x00000004, - VK_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005, - VK_BLEND_SRC_ALPHA = 0x00000006, - VK_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007, - VK_BLEND_DEST_ALPHA = 0x00000008, - VK_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009, - VK_BLEND_CONSTANT_COLOR = 0x0000000a, - VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b, - VK_BLEND_CONSTANT_ALPHA = 0x0000000c, - VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d, - VK_BLEND_SRC_ALPHA_SATURATE = 0x0000000e, - VK_BLEND_SRC1_COLOR = 0x0000000f, - VK_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010, - VK_BLEND_SRC1_ALPHA = 0x00000011, - VK_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012, - - VK_ENUM_RANGE(BLEND, ZERO, ONE_MINUS_SRC1_ALPHA) -} VkBlend; - -typedef enum VkBlendOp_ -{ - VK_BLEND_OP_ADD = 0x00000000, - VK_BLEND_OP_SUBTRACT = 0x00000001, - VK_BLEND_OP_REVERSE_SUBTRACT = 0x00000002, - VK_BLEND_OP_MIN = 0x00000003, - VK_BLEND_OP_MAX = 0x00000004, - - VK_ENUM_RANGE(BLEND_OP, ADD, MAX) -} VkBlendOp; - -typedef enum VkStencilOp_ -{ - VK_STENCIL_OP_KEEP = 0x00000000, - VK_STENCIL_OP_ZERO = 0x00000001, - VK_STENCIL_OP_REPLACE = 0x00000002, - VK_STENCIL_OP_INC_CLAMP = 0x00000003, - VK_STENCIL_OP_DEC_CLAMP = 0x00000004, - VK_STENCIL_OP_INVERT = 0x00000005, - VK_STENCIL_OP_INC_WRAP = 0x00000006, - VK_STENCIL_OP_DEC_WRAP = 0x00000007, - - VK_ENUM_RANGE(STENCIL_OP, KEEP, DEC_WRAP) -} VkStencilOp; - -typedef enum VkLogicOp_ -{ - VK_LOGIC_OP_COPY = 0x00000000, - VK_LOGIC_OP_CLEAR = 0x00000001, - VK_LOGIC_OP_AND = 0x00000002, - VK_LOGIC_OP_AND_REVERSE = 0x00000003, - VK_LOGIC_OP_AND_INVERTED = 0x00000004, - VK_LOGIC_OP_NOOP = 0x00000005, - VK_LOGIC_OP_XOR = 0x00000006, - VK_LOGIC_OP_OR = 0x00000007, - VK_LOGIC_OP_NOR = 0x00000008, - VK_LOGIC_OP_EQUIV = 0x00000009, - VK_LOGIC_OP_INVERT = 0x0000000a, - VK_LOGIC_OP_OR_REVERSE = 0x0000000b, - VK_LOGIC_OP_COPY_INVERTED = 0x0000000c, - VK_LOGIC_OP_OR_INVERTED = 0x0000000d, - VK_LOGIC_OP_NAND = 0x0000000e, - VK_LOGIC_OP_SET = 0x0000000f, - - VK_ENUM_RANGE(LOGIC_OP, COPY, SET) -} VkLogicOp; - -typedef enum VkSystemAllocType_ -{ - VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0x00000000, - VK_SYSTEM_ALLOC_TYPE_INTERNAL = 0x00000001, - VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 0x00000002, - VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 0x00000003, - VK_SYSTEM_ALLOC_TYPE_DEBUG = 0x00000004, - - VK_ENUM_RANGE(SYSTEM_ALLOC_TYPE, API_OBJECT, DEBUG) -} VkSystemAllocType; - -typedef enum VkPhysicalDeviceType_ -{ - VK_PHYSICAL_DEVICE_TYPE_OTHER = 0x00000000, - VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 0x00000001, - VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 0x00000002, - VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 0x00000003, - VK_PHYSICAL_DEVICE_TYPE_CPU = 0x00000004, - - VK_ENUM_RANGE(PHYSICAL_DEVICE_TYPE, OTHER, CPU) -} VkPhysicalDeviceType; - -typedef enum VkPhysicalDeviceInfoType_ -{ - // Info type for vkGetPhysicalDeviceInfo() - VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES = 0x00000000, - VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE = 0x00000001, - VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES = 0x00000002, - VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES = 0x00000003, - - VK_ENUM_RANGE(PHYSICAL_DEVICE_INFO_TYPE, PROPERTIES, MEMORY_PROPERTIES) -} VkPhysicalDeviceInfoType; - -typedef enum VkExtensionInfoType_ -{ - // Info type for vkGetGlobalExtensionInfo() and vkGetPhysicalDeviceExtensionInfo() - VK_EXTENSION_INFO_TYPE_COUNT = 0x00000000, - VK_EXTENSION_INFO_TYPE_PROPERTIES = 0x00000001, - - VK_ENUM_RANGE(EXTENSION_INFO_TYPE, COUNT, PROPERTIES) -} VkExtensionInfoType; - -typedef enum VkFormatInfoType_ -{ - // Info type for vkGetFormatInfo() - VK_FORMAT_INFO_TYPE_PROPERTIES = 0x00000000, - - VK_ENUM_RANGE(FORMAT_INFO_TYPE, PROPERTIES, PROPERTIES) -} VkFormatInfoType; - -typedef enum VkSubresourceInfoType_ -{ - // Info type for vkGetImageSubresourceInfo() - VK_SUBRESOURCE_INFO_TYPE_LAYOUT = 0x00000000, - - VK_ENUM_RANGE(SUBRESOURCE_INFO_TYPE, LAYOUT, LAYOUT) -} VkSubresourceInfoType; - -typedef enum VkObjectInfoType_ -{ - // Info type for vkGetObjectInfo() - VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT = 0x00000000, - VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000001, - - VK_ENUM_RANGE(OBJECT_INFO_TYPE, MEMORY_ALLOCATION_COUNT, MEMORY_REQUIREMENTS) -} VkObjectInfoType; - -typedef enum VkVertexInputStepRate_ -{ - VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0, - VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1, - VK_VERTEX_INPUT_STEP_RATE_DRAW = 0x2, //Optional - - VK_ENUM_RANGE(VERTEX_INPUT_STEP_RATE, VERTEX, DRAW) -} VkVertexInputStepRate; - -// Vulkan format definitions -typedef enum VkFormat_ -{ - VK_FORMAT_UNDEFINED = 0x00000000, - VK_FORMAT_R4G4_UNORM = 0x00000001, - VK_FORMAT_R4G4_USCALED = 0x00000002, - VK_FORMAT_R4G4B4A4_UNORM = 0x00000003, - VK_FORMAT_R4G4B4A4_USCALED = 0x00000004, - VK_FORMAT_R5G6B5_UNORM = 0x00000005, - VK_FORMAT_R5G6B5_USCALED = 0x00000006, - VK_FORMAT_R5G5B5A1_UNORM = 0x00000007, - VK_FORMAT_R5G5B5A1_USCALED = 0x00000008, - VK_FORMAT_R8_UNORM = 0x00000009, - VK_FORMAT_R8_SNORM = 0x0000000A, - VK_FORMAT_R8_USCALED = 0x0000000B, - VK_FORMAT_R8_SSCALED = 0x0000000C, - VK_FORMAT_R8_UINT = 0x0000000D, - VK_FORMAT_R8_SINT = 0x0000000E, - VK_FORMAT_R8_SRGB = 0x0000000F, - VK_FORMAT_R8G8_UNORM = 0x00000010, - VK_FORMAT_R8G8_SNORM = 0x00000011, - VK_FORMAT_R8G8_USCALED = 0x00000012, - VK_FORMAT_R8G8_SSCALED = 0x00000013, - VK_FORMAT_R8G8_UINT = 0x00000014, - VK_FORMAT_R8G8_SINT = 0x00000015, - VK_FORMAT_R8G8_SRGB = 0x00000016, - VK_FORMAT_R8G8B8_UNORM = 0x00000017, - VK_FORMAT_R8G8B8_SNORM = 0x00000018, - VK_FORMAT_R8G8B8_USCALED = 0x00000019, - VK_FORMAT_R8G8B8_SSCALED = 0x0000001A, - VK_FORMAT_R8G8B8_UINT = 0x0000001B, - VK_FORMAT_R8G8B8_SINT = 0x0000001C, - VK_FORMAT_R8G8B8_SRGB = 0x0000001D, - VK_FORMAT_R8G8B8A8_UNORM = 0x0000001E, - VK_FORMAT_R8G8B8A8_SNORM = 0x0000001F, - VK_FORMAT_R8G8B8A8_USCALED = 0x00000020, - VK_FORMAT_R8G8B8A8_SSCALED = 0x00000021, - VK_FORMAT_R8G8B8A8_UINT = 0x00000022, - VK_FORMAT_R8G8B8A8_SINT = 0x00000023, - VK_FORMAT_R8G8B8A8_SRGB = 0x00000024, - VK_FORMAT_R10G10B10A2_UNORM = 0x00000025, - VK_FORMAT_R10G10B10A2_SNORM = 0x00000026, - VK_FORMAT_R10G10B10A2_USCALED = 0x00000027, - VK_FORMAT_R10G10B10A2_SSCALED = 0x00000028, - VK_FORMAT_R10G10B10A2_UINT = 0x00000029, - VK_FORMAT_R10G10B10A2_SINT = 0x0000002A, - VK_FORMAT_R16_UNORM = 0x0000002B, - VK_FORMAT_R16_SNORM = 0x0000002C, - VK_FORMAT_R16_USCALED = 0x0000002D, - VK_FORMAT_R16_SSCALED = 0x0000002E, - VK_FORMAT_R16_UINT = 0x0000002F, - VK_FORMAT_R16_SINT = 0x00000030, - VK_FORMAT_R16_SFLOAT = 0x00000031, - VK_FORMAT_R16G16_UNORM = 0x00000032, - VK_FORMAT_R16G16_SNORM = 0x00000033, - VK_FORMAT_R16G16_USCALED = 0x00000034, - VK_FORMAT_R16G16_SSCALED = 0x00000035, - VK_FORMAT_R16G16_UINT = 0x00000036, - VK_FORMAT_R16G16_SINT = 0x00000037, - VK_FORMAT_R16G16_SFLOAT = 0x00000038, - VK_FORMAT_R16G16B16_UNORM = 0x00000039, - VK_FORMAT_R16G16B16_SNORM = 0x0000003A, - VK_FORMAT_R16G16B16_USCALED = 0x0000003B, - VK_FORMAT_R16G16B16_SSCALED = 0x0000003C, - VK_FORMAT_R16G16B16_UINT = 0x0000003D, - VK_FORMAT_R16G16B16_SINT = 0x0000003E, - VK_FORMAT_R16G16B16_SFLOAT = 0x0000003F, - VK_FORMAT_R16G16B16A16_UNORM = 0x00000040, - VK_FORMAT_R16G16B16A16_SNORM = 0x00000041, - VK_FORMAT_R16G16B16A16_USCALED = 0x00000042, - VK_FORMAT_R16G16B16A16_SSCALED = 0x00000043, - VK_FORMAT_R16G16B16A16_UINT = 0x00000044, - VK_FORMAT_R16G16B16A16_SINT = 0x00000045, - VK_FORMAT_R16G16B16A16_SFLOAT = 0x00000046, - VK_FORMAT_R32_UINT = 0x00000047, - VK_FORMAT_R32_SINT = 0x00000048, - VK_FORMAT_R32_SFLOAT = 0x00000049, - VK_FORMAT_R32G32_UINT = 0x0000004A, - VK_FORMAT_R32G32_SINT = 0x0000004B, - VK_FORMAT_R32G32_SFLOAT = 0x0000004C, - VK_FORMAT_R32G32B32_UINT = 0x0000004D, - VK_FORMAT_R32G32B32_SINT = 0x0000004E, - VK_FORMAT_R32G32B32_SFLOAT = 0x0000004F, - VK_FORMAT_R32G32B32A32_UINT = 0x00000050, - VK_FORMAT_R32G32B32A32_SINT = 0x00000051, - VK_FORMAT_R32G32B32A32_SFLOAT = 0x00000052, - VK_FORMAT_R64_SFLOAT = 0x00000053, - VK_FORMAT_R64G64_SFLOAT = 0x00000054, - VK_FORMAT_R64G64B64_SFLOAT = 0x00000055, - VK_FORMAT_R64G64B64A64_SFLOAT = 0x00000056, - VK_FORMAT_R11G11B10_UFLOAT = 0x00000057, - VK_FORMAT_R9G9B9E5_UFLOAT = 0x00000058, - VK_FORMAT_D16_UNORM = 0x00000059, - VK_FORMAT_D24_UNORM = 0x0000005A, - VK_FORMAT_D32_SFLOAT = 0x0000005B, - VK_FORMAT_S8_UINT = 0x0000005C, - VK_FORMAT_D16_UNORM_S8_UINT = 0x0000005D, - VK_FORMAT_D24_UNORM_S8_UINT = 0x0000005E, - VK_FORMAT_D32_SFLOAT_S8_UINT = 0x0000005F, - VK_FORMAT_BC1_RGB_UNORM = 0x00000060, - VK_FORMAT_BC1_RGB_SRGB = 0x00000061, - VK_FORMAT_BC1_RGBA_UNORM = 0x00000062, - VK_FORMAT_BC1_RGBA_SRGB = 0x00000063, - VK_FORMAT_BC2_UNORM = 0x00000064, - VK_FORMAT_BC2_SRGB = 0x00000065, - VK_FORMAT_BC3_UNORM = 0x00000066, - VK_FORMAT_BC3_SRGB = 0x00000067, - VK_FORMAT_BC4_UNORM = 0x00000068, - VK_FORMAT_BC4_SNORM = 0x00000069, - VK_FORMAT_BC5_UNORM = 0x0000006A, - VK_FORMAT_BC5_SNORM = 0x0000006B, - VK_FORMAT_BC6H_UFLOAT = 0x0000006C, - VK_FORMAT_BC6H_SFLOAT = 0x0000006D, - VK_FORMAT_BC7_UNORM = 0x0000006E, - VK_FORMAT_BC7_SRGB = 0x0000006F, - VK_FORMAT_ETC2_R8G8B8_UNORM = 0x00000070, - VK_FORMAT_ETC2_R8G8B8_SRGB = 0x00000071, - VK_FORMAT_ETC2_R8G8B8A1_UNORM = 0x00000072, - VK_FORMAT_ETC2_R8G8B8A1_SRGB = 0x00000073, - VK_FORMAT_ETC2_R8G8B8A8_UNORM = 0x00000074, - VK_FORMAT_ETC2_R8G8B8A8_SRGB = 0x00000075, - VK_FORMAT_EAC_R11_UNORM = 0x00000076, - VK_FORMAT_EAC_R11_SNORM = 0x00000077, - VK_FORMAT_EAC_R11G11_UNORM = 0x00000078, - VK_FORMAT_EAC_R11G11_SNORM = 0x00000079, - VK_FORMAT_ASTC_4x4_UNORM = 0x0000007A, - VK_FORMAT_ASTC_4x4_SRGB = 0x0000007B, - VK_FORMAT_ASTC_5x4_UNORM = 0x0000007C, - VK_FORMAT_ASTC_5x4_SRGB = 0x0000007D, - VK_FORMAT_ASTC_5x5_UNORM = 0x0000007E, - VK_FORMAT_ASTC_5x5_SRGB = 0x0000007F, - VK_FORMAT_ASTC_6x5_UNORM = 0x00000080, - VK_FORMAT_ASTC_6x5_SRGB = 0x00000081, - VK_FORMAT_ASTC_6x6_UNORM = 0x00000082, - VK_FORMAT_ASTC_6x6_SRGB = 0x00000083, - VK_FORMAT_ASTC_8x5_UNORM = 0x00000084, - VK_FORMAT_ASTC_8x5_SRGB = 0x00000085, - VK_FORMAT_ASTC_8x6_UNORM = 0x00000086, - VK_FORMAT_ASTC_8x6_SRGB = 0x00000087, - VK_FORMAT_ASTC_8x8_UNORM = 0x00000088, - VK_FORMAT_ASTC_8x8_SRGB = 0x00000089, - VK_FORMAT_ASTC_10x5_UNORM = 0x0000008A, - VK_FORMAT_ASTC_10x5_SRGB = 0x0000008B, - VK_FORMAT_ASTC_10x6_UNORM = 0x0000008C, - VK_FORMAT_ASTC_10x6_SRGB = 0x0000008D, - VK_FORMAT_ASTC_10x8_UNORM = 0x0000008E, - VK_FORMAT_ASTC_10x8_SRGB = 0x0000008F, - VK_FORMAT_ASTC_10x10_UNORM = 0x00000090, - VK_FORMAT_ASTC_10x10_SRGB = 0x00000091, - VK_FORMAT_ASTC_12x10_UNORM = 0x00000092, - VK_FORMAT_ASTC_12x10_SRGB = 0x00000093, - VK_FORMAT_ASTC_12x12_UNORM = 0x00000094, - VK_FORMAT_ASTC_12x12_SRGB = 0x00000095, - VK_FORMAT_B4G4R4A4_UNORM = 0x00000096, - VK_FORMAT_B5G5R5A1_UNORM = 0x00000097, - VK_FORMAT_B5G6R5_UNORM = 0x00000098, - VK_FORMAT_B5G6R5_USCALED = 0x00000099, - VK_FORMAT_B8G8R8_UNORM = 0x0000009A, - VK_FORMAT_B8G8R8_SNORM = 0x0000009B, - VK_FORMAT_B8G8R8_USCALED = 0x0000009C, - VK_FORMAT_B8G8R8_SSCALED = 0x0000009D, - VK_FORMAT_B8G8R8_UINT = 0x0000009E, - VK_FORMAT_B8G8R8_SINT = 0x0000009F, - VK_FORMAT_B8G8R8_SRGB = 0x000000A0, - VK_FORMAT_B8G8R8A8_UNORM = 0x000000A1, - VK_FORMAT_B8G8R8A8_SNORM = 0x000000A2, - VK_FORMAT_B8G8R8A8_USCALED = 0x000000A3, - VK_FORMAT_B8G8R8A8_SSCALED = 0x000000A4, - VK_FORMAT_B8G8R8A8_UINT = 0x000000A5, - VK_FORMAT_B8G8R8A8_SINT = 0x000000A6, - VK_FORMAT_B8G8R8A8_SRGB = 0x000000A7, - VK_FORMAT_B10G10R10A2_UNORM = 0x000000A8, - VK_FORMAT_B10G10R10A2_SNORM = 0x000000A9, - VK_FORMAT_B10G10R10A2_USCALED = 0x000000AA, - VK_FORMAT_B10G10R10A2_SSCALED = 0x000000AB, - VK_FORMAT_B10G10R10A2_UINT = 0x000000AC, - VK_FORMAT_B10G10R10A2_SINT = 0x000000AD, - - VK_ENUM_RANGE(FORMAT, UNDEFINED, B10G10R10A2_SINT) -} VkFormat; - -// Shader stage enumerant -typedef enum VkShaderStage_ -{ - VK_SHADER_STAGE_VERTEX = 0, - VK_SHADER_STAGE_TESS_CONTROL = 1, - VK_SHADER_STAGE_TESS_EVALUATION = 2, - VK_SHADER_STAGE_GEOMETRY = 3, - VK_SHADER_STAGE_FRAGMENT = 4, - VK_SHADER_STAGE_COMPUTE = 5, - - VK_ENUM_RANGE(SHADER_STAGE, VERTEX, COMPUTE) -} VkShaderStage; - -// Structure type enumerant -typedef enum VkStructureType_ -{ - VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, - VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, - VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, - VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 3, - VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 4, - VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO = 5, - VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 6, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 7, - VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 8, - VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 22, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 33, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 34, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 35, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 36, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, - VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 38, - VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 39, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 40, - VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 41, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 42, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 45, - VK_STRUCTURE_TYPE_UPDATE_SAMPLERS = 46, - VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES = 47, - VK_STRUCTURE_TYPE_UPDATE_IMAGES = 48, - VK_STRUCTURE_TYPE_UPDATE_BUFFERS = 49, - VK_STRUCTURE_TYPE_UPDATE_AS_COPY = 50, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 51, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 52, - - VK_ENUM_RANGE(STRUCTURE_TYPE, APPLICATION_INFO, PIPELINE_LAYOUT_CREATE_INFO) -} VkStructureType; - -// Object type enumerant -typedef enum VkObjectType_ -{ - VK_OBJECT_TYPE_INSTANCE = 0, - VK_OBJECT_TYPE_PHYSICAL_DEVICE = 1, - VK_OBJECT_TYPE_DEVICE = 2, - VK_OBJECT_TYPE_QUEUE = 3, - VK_OBJECT_TYPE_COMMAND_BUFFER = 4, - VK_OBJECT_TYPE_DEVICE_MEMORY = 5, - VK_OBJECT_TYPE_BUFFER = 6, - VK_OBJECT_TYPE_BUFFER_VIEW = 7, - VK_OBJECT_TYPE_IMAGE = 8, - VK_OBJECT_TYPE_IMAGE_VIEW = 9, - VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW = 10, - VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW = 11, - VK_OBJECT_TYPE_SHADER = 12, - VK_OBJECT_TYPE_PIPELINE = 13, - VK_OBJECT_TYPE_PIPELINE_LAYOUT = 14, - VK_OBJECT_TYPE_SAMPLER = 15, - VK_OBJECT_TYPE_DESCRIPTOR_SET = 16, - VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 17, - VK_OBJECT_TYPE_DESCRIPTOR_POOL = 18, - VK_OBJECT_TYPE_DYNAMIC_VP_STATE = 19, - VK_OBJECT_TYPE_DYNAMIC_RS_STATE = 20, - VK_OBJECT_TYPE_DYNAMIC_CB_STATE = 21, - VK_OBJECT_TYPE_DYNAMIC_DS_STATE = 22, - VK_OBJECT_TYPE_FENCE = 23, - VK_OBJECT_TYPE_SEMAPHORE = 24, - VK_OBJECT_TYPE_EVENT = 25, - VK_OBJECT_TYPE_QUERY_POOL = 26, - VK_OBJECT_TYPE_FRAMEBUFFER = 27, - VK_OBJECT_TYPE_RENDER_PASS = 28, - - // Valid ranges for core Vulkan: - VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE, - VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_RENDER_PASS, - VK_NUM_OBJECT_TYPE = (VK_OBJECT_TYPE_END_RANGE - VK_OBJECT_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkObjectType) -} VkObjectType; - -// ------------------------------------------------------------------------------------------------ -// Error and return codes - -typedef enum VkResult_ -{ - // Return codes for successful operation execution (> = 0) - VK_SUCCESS = 0x0000000, - VK_UNSUPPORTED = 0x0000001, - VK_NOT_READY = 0x0000002, - VK_TIMEOUT = 0x0000003, - VK_EVENT_SET = 0x0000004, - VK_EVENT_RESET = 0x0000005, - - // Error codes (negative values) - VK_ERROR_UNKNOWN = -(0x00000001), - VK_ERROR_UNAVAILABLE = -(0x00000002), - VK_ERROR_INITIALIZATION_FAILED = -(0x00000003), - VK_ERROR_OUT_OF_HOST_MEMORY = -(0x00000004), - VK_ERROR_OUT_OF_DEVICE_MEMORY = -(0x00000005), - VK_ERROR_DEVICE_ALREADY_CREATED = -(0x00000006), - VK_ERROR_DEVICE_LOST = -(0x00000007), - VK_ERROR_INVALID_POINTER = -(0x00000008), - VK_ERROR_INVALID_VALUE = -(0x00000009), - VK_ERROR_INVALID_HANDLE = -(0x0000000A), - VK_ERROR_INVALID_ORDINAL = -(0x0000000B), - VK_ERROR_INVALID_MEMORY_SIZE = -(0x0000000C), - VK_ERROR_INVALID_EXTENSION = -(0x0000000D), - VK_ERROR_INVALID_FLAGS = -(0x0000000E), - VK_ERROR_INVALID_ALIGNMENT = -(0x0000000F), - VK_ERROR_INVALID_FORMAT = -(0x00000010), - VK_ERROR_INVALID_IMAGE = -(0x00000011), - VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -(0x00000012), - VK_ERROR_INVALID_QUEUE_TYPE = -(0x00000013), - VK_ERROR_INVALID_OBJECT_TYPE = -(0x00000014), - VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -(0x00000015), - VK_ERROR_BAD_SHADER_CODE = -(0x00000016), - VK_ERROR_BAD_PIPELINE_DATA = -(0x00000017), - VK_ERROR_TOO_MANY_MEMORY_REFERENCES = -(0x00000018), - VK_ERROR_NOT_MAPPABLE = -(0x00000019), - VK_ERROR_MEMORY_MAP_FAILED = -(0x0000001A), - VK_ERROR_MEMORY_UNMAP_FAILED = -(0x0000001B), - VK_ERROR_INCOMPATIBLE_DEVICE = -(0x0000001C), - VK_ERROR_INCOMPATIBLE_DRIVER = -(0x0000001D), - VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -(0x0000001E), - VK_ERROR_BUILDING_COMMAND_BUFFER = -(0x0000001F), - VK_ERROR_MEMORY_NOT_BOUND = -(0x00000020), - VK_ERROR_INCOMPATIBLE_QUEUE = -(0x00000021), - VK_ERROR_NOT_SHAREABLE = -(0x00000022), - - VK_MAX_ENUM(RESULT) -} VkResult; - -// ------------------------------------------------------------------------------------------------ -// Flags - -// Device creation flags -typedef VkFlags VkDeviceCreateFlags; -typedef enum VkDeviceCreateFlagBits_ -{ - VK_DEVICE_CREATE_VALIDATION_BIT = VK_BIT(0), - VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT = VK_BIT(1), -} VkDeviceCreateFlagBits; - -// Queue capabilities -typedef VkFlags VkQueueFlags; -typedef enum VkQueueFlagBits_ -{ - VK_QUEUE_GRAPHICS_BIT = VK_BIT(0), // Queue supports graphics operations - VK_QUEUE_COMPUTE_BIT = VK_BIT(1), // Queue supports compute operations - VK_QUEUE_DMA_BIT = VK_BIT(2), // Queue supports DMA operations - VK_QUEUE_MEMMGR_BIT = VK_BIT(3), // Queue supports memory management operations - VK_QUEUE_EXTENDED_BIT = VK_BIT(30), // Extended queue -} VkQueueFlagBits; - -// Memory properties passed into vkAllocMemory(). -typedef VkFlags VkMemoryPropertyFlags; -typedef enum VkMemoryPropertyFlagBits_ -{ - VK_MEMORY_PROPERTY_DEVICE_ONLY = 0, // If otherwise stated, then allocate memory on device - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = VK_BIT(0), // Memory should be mappable by host - VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT = VK_BIT(1), // Memory should be coherent between host and device accesses - VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = VK_BIT(2), // Memory should not be cached by the host - VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = VK_BIT(3), // Memory should support host write combining - VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL = VK_BIT(4), // If set, prefer host access - VK_MEMORY_PROPERTY_SHAREABLE_BIT = VK_BIT(5), -} VkMemoryPropertyFlagBits; - -// Memory output flags passed to resource transition commands -typedef VkFlags VkMemoryOutputFlags; -typedef enum VkMemoryOutputFlagBits_ -{ - VK_MEMORY_OUTPUT_CPU_WRITE_BIT = VK_BIT(0), // Controls output coherency of CPU writes - VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = VK_BIT(1), // Controls output coherency of generic shader writes - VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = VK_BIT(2), // Controls output coherency of color attachment writes - VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(3), // Controls output coherency of depth/stencil attachment writes - VK_MEMORY_OUTPUT_TRANSFER_BIT = VK_BIT(4), // Controls output coherency of transfer operations -} VkMemoryOutputFlagBits; - -// Memory input flags passed to resource transition commands -typedef VkFlags VkMemoryInputFlags; -typedef enum VkMemoryInputFlagBits_ -{ - VK_MEMORY_INPUT_CPU_READ_BIT = VK_BIT(0), // Controls input coherency of CPU reads - VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = VK_BIT(1), // Controls input coherency of indirect command reads - VK_MEMORY_INPUT_INDEX_FETCH_BIT = VK_BIT(2), // Controls input coherency of index fetches - VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = VK_BIT(3), // Controls input coherency of vertex attribute fetches - VK_MEMORY_INPUT_UNIFORM_READ_BIT = VK_BIT(4), // Controls input coherency of uniform buffer reads - VK_MEMORY_INPUT_SHADER_READ_BIT = VK_BIT(5), // Controls input coherency of generic shader reads - VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = VK_BIT(6), // Controls input coherency of color attachment reads - VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(7), // Controls input coherency of depth/stencil attachment reads - VK_MEMORY_INPUT_TRANSFER_BIT = VK_BIT(8), // Controls input coherency of transfer operations -} VkMemoryInputFlagBits; - -// Buffer usage flags -typedef VkFlags VkBufferUsageFlags; -typedef enum VkBufferUsageFlagBits_ -{ - VK_BUFFER_USAGE_GENERAL = 0, // No special usage - VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0), // Can be used as a source of transfer operations - VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1), // Can be used as a destination of transfer operations - VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(2), // Can be used as TBO - VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(3), // Can be used as IBO - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = VK_BIT(4), // Can be used as UBO - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = VK_BIT(5), // Can be used as SSBO - VK_BUFFER_USAGE_INDEX_BUFFER_BIT = VK_BIT(6), // Can be used as source of fixed function index fetch (index buffer) - VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = VK_BIT(7), // Can be used as source of fixed function vertex fetch (VBO) - VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = VK_BIT(8), // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) -} VkBufferUsageFlagBits; - -// Buffer creation flags -typedef VkFlags VkBufferCreateFlags; -typedef enum VkBufferCreateFlagBits_ -{ - VK_BUFFER_CREATE_SHAREABLE_BIT = VK_BIT(0), // Buffer should be shareable - VK_BUFFER_CREATE_SPARSE_BIT = VK_BIT(1), // Buffer should support sparse backing -} VkBufferCreateFlagBits; - -// Shader stage flags -typedef VkFlags VkShaderStageFlags; -typedef enum VkShaderStageFlagBits_ -{ - VK_SHADER_STAGE_VERTEX_BIT = VK_BIT(0), - VK_SHADER_STAGE_TESS_CONTROL_BIT = VK_BIT(1), - VK_SHADER_STAGE_TESS_EVALUATION_BIT = VK_BIT(2), - VK_SHADER_STAGE_GEOMETRY_BIT = VK_BIT(3), - VK_SHADER_STAGE_FRAGMENT_BIT = VK_BIT(4), - VK_SHADER_STAGE_COMPUTE_BIT = VK_BIT(5), - - VK_SHADER_STAGE_ALL = 0x7FFFFFFF, -} VkShaderStageFlagBits; - -// Image usage flags -typedef VkFlags VkImageUsageFlags; -typedef enum VkImageUsageFlagBits_ -{ - VK_IMAGE_USAGE_GENERAL = 0, // No special usage - VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0), // Can be used as a source of transfer operations - VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1), // Can be used as a destination of transfer operations - VK_IMAGE_USAGE_SAMPLED_BIT = VK_BIT(2), // Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) - VK_IMAGE_USAGE_STORAGE_BIT = VK_BIT(3), // Can be used as storage image (STORAGE_IMAGE descriptor type) - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = VK_BIT(4), // Can be used as framebuffer color attachment - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = VK_BIT(5), // Can be used as framebuffer depth/stencil attachment - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = VK_BIT(6), // Image data not needed outside of rendering -} VkImageUsageFlagBits; - -// Image creation flags -typedef VkFlags VkImageCreateFlags; -typedef enum VkImageCreateFlagBits_ -{ - VK_IMAGE_CREATE_INVARIANT_DATA_BIT = VK_BIT(0), - VK_IMAGE_CREATE_CLONEABLE_BIT = VK_BIT(1), - VK_IMAGE_CREATE_SHAREABLE_BIT = VK_BIT(2), // Image should be shareable - VK_IMAGE_CREATE_SPARSE_BIT = VK_BIT(3), // Image should support sparse backing - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = VK_BIT(4), // Allows image views to have different format than the base image - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = VK_BIT(5), // Allows creating image views with cube type from the created image -} VkImageCreateFlagBits; - -// Depth-stencil view creation flags -typedef VkFlags VkDepthStencilViewCreateFlags; -typedef enum VkDepthStencilViewCreateFlagBits_ -{ - VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = VK_BIT(0), - VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = VK_BIT(1), -} VkDepthStencilViewCreateFlagBits; - -// Pipeline creation flags -typedef VkFlags VkPipelineCreateFlags; -typedef enum VkPipelineCreateFlagBits_ -{ - VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = VK_BIT(0), - VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = VK_BIT(1), -} VkPipelineCreateFlagBits; - -// Channel flags -typedef VkFlags VkChannelFlags; -typedef enum VkChannelFlagBits_ -{ - VK_CHANNEL_R_BIT = VK_BIT(0), - VK_CHANNEL_G_BIT = VK_BIT(1), - VK_CHANNEL_B_BIT = VK_BIT(2), - VK_CHANNEL_A_BIT = VK_BIT(3), -} VkChannelFlagBits; - -// Fence creation flags -typedef VkFlags VkFenceCreateFlags; -typedef enum VkFenceCreateFlagBits_ -{ - VK_FENCE_CREATE_SIGNALED_BIT = VK_BIT(0), -} VkFenceCreateFlagBits; - -// Semaphore creation flags -typedef VkFlags VkSemaphoreCreateFlags; -typedef enum VkSemaphoreCreateFlagBits_ -{ - VK_SEMAPHORE_CREATE_SHAREABLE_BIT = VK_BIT(0), -} VkSemaphoreCreateFlagBits; - -// Format capability flags -typedef VkFlags VkFormatFeatureFlags; -typedef enum VkFormatFeatureFlagBits_ -{ - VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = VK_BIT(0), // Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) - VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = VK_BIT(1), // Format can be used for storage images (STORAGE_IMAGE descriptor type) - VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = VK_BIT(2), // Format supports atomic operations in case it's used for storage images - VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(3), // Format can be used for uniform texel buffers (TBOs) - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(4), // Format can be used for storage texel buffers (IBOs) - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = VK_BIT(5), // Format supports atomic operations in case it's used for storage texel buffers - VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = VK_BIT(6), // Format can be used for vertex buffers (VBOs) - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = VK_BIT(7), // Format can be used for color attachment images - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = VK_BIT(8), // Format supports blending in case it's used for color attachment images - VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(9), // Format can be used for depth/stencil attachment images - VK_FORMAT_FEATURE_CONVERSION_BIT = VK_BIT(10), // Format can be used as the source or destination of format converting blits -} VkFormatFeatureFlagBits; - -// Query control flags -typedef VkFlags VkQueryControlFlags; -typedef enum VkQueryControlFlagBits_ -{ - VK_QUERY_CONTROL_CONSERVATIVE_BIT = VK_BIT(0), // Allow conservative results to be collected by the query -} VkQueryControlFlagBits; - -// Query result flags -typedef VkFlags VkQueryResultFlags; -typedef enum VkQueryResultFlagBits_ -{ - VK_QUERY_RESULT_32_BIT = 0, // Results of the queries are written to the destination buffer as 32-bit values - VK_QUERY_RESULT_64_BIT = VK_BIT(0), // Results of the queries are written to the destination buffer as 64-bit values - VK_QUERY_RESULT_NO_WAIT_BIT = 0, // Results of the queries aren't waited on before proceeding with the result copy - VK_QUERY_RESULT_WAIT_BIT = VK_BIT(1), // Results of the queries are waited on before proceeding with the result copy - VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = VK_BIT(2), // Besides the results of the query, the availability of the results is also written - VK_QUERY_RESULT_PARTIAL_BIT = VK_BIT(3), // Copy the partial results of the query even if the final results aren't available -} VkQueryResultFlagBits; - -// Physical device compatibility flags -typedef VkFlags VkPhysicalDeviceCompatibilityFlags; -typedef enum VkPhysicalDeviceCompatibilityFlagBits_ -{ - VK_PHYSICAL_DEVICE_COMPATIBILITY_FEATURES_BIT = VK_BIT(0), - VK_PHYSICAL_DEVICE_COMPATIBILITY_IQ_MATCH_BIT = VK_BIT(1), - VK_PHYSICAL_DEVICE_COMPATIBILITY_PEER_TRANSFER_BIT = VK_BIT(2), - VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_MEMORY_BIT = VK_BIT(3), - VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_SYNC_BIT = VK_BIT(4), - VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE0_DISPLAY_BIT = VK_BIT(5), - VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE1_DISPLAY_BIT = VK_BIT(6), -} VkPhysicalDeviceCompatibilityFlagBits; - -// Shader creation flags -typedef VkFlags VkShaderCreateFlags; - -// Event creation flags -typedef VkFlags VkEventCreateFlags; - -// Command buffer creation flags -typedef VkFlags VkCmdBufferCreateFlags; - -// Command buffer optimization flags -typedef VkFlags VkCmdBufferOptimizeFlags; -typedef enum VkCmdBufferOptimizeFlagBits_ -{ - VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = VK_BIT(0), - VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = VK_BIT(1), - VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = VK_BIT(2), - VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = VK_BIT(3), -} VkCmdBufferOptimizeFlagBits; - -// Pipeline statistics flags -typedef VkFlags VkQueryPipelineStatisticFlags; -typedef enum VkQueryPipelineStatisticFlagBits_ { - VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = VK_BIT(0), // Optional - VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = VK_BIT(1), // Optional - VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = VK_BIT(2), // Optional - VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = VK_BIT(3), // Optional - VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = VK_BIT(4), // Optional - VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = VK_BIT(5), // Optional - VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = VK_BIT(6), // Optional - VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = VK_BIT(7), // Optional - VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = VK_BIT(8), // Optional - VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = VK_BIT(9), // Optional - VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = VK_BIT(10), // Optional -} VkQueryPipelineStatisticFlagBits; - -// Memory mapping flags -typedef VkFlags VkMemoryMapFlags; - -// ------------------------------------------------------------------------------------------------ -// Vulkan structures - -typedef struct VkOffset2D_ -{ - int32_t x; - int32_t y; -} VkOffset2D; - -typedef struct VkOffset3D_ -{ - int32_t x; - int32_t y; - int32_t z; -} VkOffset3D; - -typedef struct VkExtent2D_ -{ - int32_t width; - int32_t height; -} VkExtent2D; - -typedef struct VkExtent3D_ -{ - int32_t width; - int32_t height; - int32_t depth; -} VkExtent3D; - -typedef struct VkViewport_ -{ - float originX; - float originY; - float width; - float height; - float minDepth; - float maxDepth; -} VkViewport; - -typedef struct VkRect_ -{ - VkOffset2D offset; - VkExtent2D extent; -} VkRect; - -typedef struct VkChannelMapping_ -{ - VkChannelSwizzle r; - VkChannelSwizzle g; - VkChannelSwizzle b; - VkChannelSwizzle a; -} VkChannelMapping; - -typedef struct VkPhysicalDeviceProperties_ -{ - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorId; - uint32_t deviceId; - VkPhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; - VkDeviceSize maxInlineMemoryUpdateSize; - uint32_t maxBoundDescriptorSets; - uint32_t maxThreadGroupSize; - uint64_t timestampFrequency; - bool32_t multiColorAttachmentClears; - uint32_t maxDescriptorSets; // at least 2? - uint32_t maxViewports; // at least 16? - uint32_t maxColorAttachments; // at least 8? -} VkPhysicalDeviceProperties; - -typedef struct VkPhysicalDevicePerformance_ -{ - float maxDeviceClock; - float aluPerClock; - float texPerClock; - float primsPerClock; - float pixelsPerClock; -} VkPhysicalDevicePerformance; - -typedef struct VkPhysicalDeviceCompatibilityInfo_ -{ - VkPhysicalDeviceCompatibilityFlags compatibilityFlags; -} VkPhysicalDeviceCompatibilityInfo; - -typedef struct VkExtensionProperties_ -{ - char extName[VK_MAX_EXTENSION_NAME]; // extension name - uint32_t version; // version of the extension specification -} VkExtensionProperties; - -typedef struct VkApplicationInfo_ -{ - VkStructureType sType; // Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO - const void* pNext; // Next structure in chain - const char* pAppName; - uint32_t appVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; -} VkApplicationInfo; - -typedef void* (VKAPI *PFN_vkAllocFunction)( - void* pUserData, - size_t size, - size_t alignment, - VkSystemAllocType allocType); - -typedef void (VKAPI *PFN_vkFreeFunction)( - void* pUserData, - void* pMem); - -typedef struct VkAllocCallbacks_ -{ - void* pUserData; - PFN_vkAllocFunction pfnAlloc; - PFN_vkFreeFunction pfnFree; -} VkAllocCallbacks; - -typedef struct VkDeviceQueueCreateInfo_ -{ - uint32_t queueNodeIndex; - uint32_t queueCount; -} VkDeviceQueueCreateInfo; - -typedef struct VkDeviceCreateInfo_ -{ - VkStructureType sType; // Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO - const void* pNext; // Pointer to next structure - uint32_t queueRecordCount; - const VkDeviceQueueCreateInfo* pRequestedQueues; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; - VkDeviceCreateFlags flags; // Device creation flags -} VkDeviceCreateInfo; - -typedef struct VkInstanceCreateInfo_ -{ - VkStructureType sType; // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO - const void* pNext; // Pointer to next structure - const VkApplicationInfo* pAppInfo; - const VkAllocCallbacks* pAllocCb; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; // layer or extension name to be enabled -} VkInstanceCreateInfo; - -// can be added to VkDeviceCreateInfo via pNext -typedef struct VkLayerCreateInfo_ -{ - VkStructureType sType; // Should be VK_STRUCTURE_TYPE_LAYER_CREATE_INFO - const void* pNext; // Pointer to next structure - uint32_t layerCount; - const char *const* ppActiveLayerNames; // layer name from the layer's vkEnumerateLayers()) -} VkLayerCreateInfo; - -typedef struct VkPhysicalDeviceQueueProperties_ -{ - VkQueueFlags queueFlags; // Queue flags - uint32_t queueCount; - bool32_t supportsTimestamps; - uint32_t maxMemReferences; // Tells how many memory references can be active for the given queue -} VkPhysicalDeviceQueueProperties; - -typedef struct VkPhysicalDeviceMemoryProperties_ -{ - bool32_t supportsMigration; - bool32_t supportsPinning; -} VkPhysicalDeviceMemoryProperties; - -typedef struct VkMemoryAllocInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO - const void* pNext; // Pointer to next structure - VkDeviceSize allocationSize; // Size of memory allocation - VkMemoryPropertyFlags memProps; // Memory property flags - VkMemoryPriority memPriority; -} VkMemoryAllocInfo; - -typedef struct VkMemoryOpenInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO - const void* pNext; // Pointer to next structure - VkDeviceMemory sharedMem; -} VkMemoryOpenInfo; - -typedef struct VkPeerMemoryOpenInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO - const void* pNext; // Pointer to next structure - VkDeviceMemory originalMem; -} VkPeerMemoryOpenInfo; - -typedef struct VkMemoryRequirements_ -{ - VkDeviceSize size; // Specified in bytes - VkDeviceSize alignment; // Specified in bytes - VkDeviceSize granularity; // Granularity on which vkQueueBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size) - VkMemoryPropertyFlags memPropsAllowed; // Allowed memory property flags - VkMemoryPropertyFlags memPropsRequired; // Required memory property flags - -} VkMemoryRequirements; - -typedef struct VkFormatProperties_ -{ - VkFormatFeatureFlags linearTilingFeatures; // Format features in case of linear tiling - VkFormatFeatureFlags optimalTilingFeatures; // Format features in case of optimal tiling -} VkFormatProperties; - -typedef struct VkBufferViewAttachInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO - const void* pNext; // Pointer to next structure - VkBufferView view; -} VkBufferViewAttachInfo; - -typedef struct VkImageViewAttachInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO - const void* pNext; // Pointer to next structure - VkImageView view; - VkImageLayout layout; -} VkImageViewAttachInfo; - -typedef struct VkUpdateSamplers_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLERS - const void* pNext; // Pointer to next structure - uint32_t binding; // Binding of the sampler (array) - uint32_t arrayIndex; // First element of the array to update or zero otherwise - uint32_t count; // Number of elements to update - const VkSampler* pSamplers; -} VkUpdateSamplers; - -typedef struct VkSamplerImageViewInfo_ -{ - VkSampler sampler; - const VkImageViewAttachInfo* pImageView; -} VkSamplerImageViewInfo; - -typedef struct VkUpdateSamplerTextures_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES - const void* pNext; // Pointer to next structure - uint32_t binding; // Binding of the combined texture sampler (array) - uint32_t arrayIndex; // First element of the array to update or zero otherwise - uint32_t count; // Number of elements to update - const VkSamplerImageViewInfo* pSamplerImageViews; -} VkUpdateSamplerTextures; - -typedef struct VkUpdateImages_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_UPDATE_IMAGES - const void* pNext; // Pointer to next structure - VkDescriptorType descriptorType; - uint32_t binding; // Binding of the image (array) - uint32_t arrayIndex; // First element of the array to update or zero otherwise - uint32_t count; // Number of elements to update - const VkImageViewAttachInfo* pImageViews; -} VkUpdateImages; - -typedef struct VkUpdateBuffers_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_UPDATE_BUFFERS - const void* pNext; // Pointer to next structure - VkDescriptorType descriptorType; - uint32_t binding; // Binding of the buffer (array) - uint32_t arrayIndex; // First element of the array to update or zero otherwise - uint32_t count; // Number of elements to update - const VkBufferViewAttachInfo* pBufferViews; -} VkUpdateBuffers; - -typedef struct VkUpdateAsCopy_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_UPDATE_AS_COPY - const void* pNext; // Pointer to next structure - VkDescriptorType descriptorType; - VkDescriptorSet descriptorSet; - uint32_t binding; - uint32_t arrayElement; - uint32_t count; -} VkUpdateAsCopy; - -typedef struct VkBufferCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO - const void* pNext; // Pointer to next structure. - VkDeviceSize size; // Specified in bytes - VkBufferUsageFlags usage; // Buffer usage flags - VkBufferCreateFlags flags; // Buffer creation flags -} VkBufferCreateInfo; - -typedef struct VkBufferViewCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO - const void* pNext; // Pointer to next structure. - VkBuffer buffer; - VkBufferViewType viewType; - VkFormat format; // Optionally specifies format of elements - VkDeviceSize offset; // Specified in bytes - VkDeviceSize range; // View size specified in bytes -} VkBufferViewCreateInfo; - -typedef struct VkImageSubresource_ -{ - VkImageAspect aspect; - uint32_t mipLevel; - uint32_t arraySlice; -} VkImageSubresource; - -typedef struct VkImageSubresourceRange_ -{ - VkImageAspect aspect; - uint32_t baseMipLevel; - uint32_t mipLevels; - uint32_t baseArraySlice; - uint32_t arraySize; -} VkImageSubresourceRange; - -typedef struct VkMemoryBarrier_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. - - VkMemoryOutputFlags outputMask; // Outputs the barrier should sync - VkMemoryInputFlags inputMask; // Inputs the barrier should sync to -} VkMemoryBarrier; - -typedef struct VkBufferMemoryBarrier_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. - - VkMemoryOutputFlags outputMask; // Outputs the barrier should sync - VkMemoryInputFlags inputMask; // Inputs the barrier should sync to - - VkBuffer buffer; // Buffer to sync - - VkDeviceSize offset; // Offset within the buffer to sync - VkDeviceSize size; // Amount of bytes to sync -} VkBufferMemoryBarrier; - -typedef struct VkImageMemoryBarrier_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER - const void* pNext; // Pointer to next structure. - - VkMemoryOutputFlags outputMask; // Outputs the barrier should sync - VkMemoryInputFlags inputMask; // Inputs the barrier should sync to - - VkImageLayout oldLayout; // Current layout of the image - VkImageLayout newLayout; // New layout to transition the image to - - VkImage image; // Image to sync - - VkImageSubresourceRange subresourceRange; // Subresource range to sync -} VkImageMemoryBarrier; - -typedef struct VkImageCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO - const void* pNext; // Pointer to next structure. - VkImageType imageType; - VkFormat format; - VkExtent3D extent; - uint32_t mipLevels; - uint32_t arraySize; - uint32_t samples; - VkImageTiling tiling; - VkImageUsageFlags usage; // Image usage flags - VkImageCreateFlags flags; // Image creation flags -} VkImageCreateInfo; - -typedef struct VkPeerImageOpenInfo_ -{ - VkImage originalImage; -} VkPeerImageOpenInfo; - -typedef struct VkSubresourceLayout_ -{ - VkDeviceSize offset; // Specified in bytes - VkDeviceSize size; // Specified in bytes - VkDeviceSize rowPitch; // Specified in bytes - VkDeviceSize depthPitch; // Specified in bytes -} VkSubresourceLayout; - -typedef struct VkImageViewCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO - const void* pNext; // Pointer to next structure - VkImage image; - VkImageViewType viewType; - VkFormat format; - VkChannelMapping channels; - VkImageSubresourceRange subresourceRange; - float minLod; -} VkImageViewCreateInfo; - -typedef struct VkColorAttachmentViewCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO - const void* pNext; // Pointer to next structure - VkImage image; - VkFormat format; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - VkImage msaaResolveImage; - VkImageSubresourceRange msaaResolveSubResource; -} VkColorAttachmentViewCreateInfo; - -typedef struct VkDepthStencilViewCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO - const void* pNext; // Pointer to next structure - VkImage image; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - VkImage msaaResolveImage; - VkImageSubresourceRange msaaResolveSubResource; - VkDepthStencilViewCreateFlags flags; // Depth stencil attachment view flags -} VkDepthStencilViewCreateInfo; - -typedef struct VkColorAttachmentBindInfo_ -{ - VkColorAttachmentView view; - VkImageLayout layout; -} VkColorAttachmentBindInfo; - -typedef struct VkDepthStencilBindInfo_ -{ - VkDepthStencilView view; - VkImageLayout layout; -} VkDepthStencilBindInfo; - -typedef struct VkBufferCopy_ -{ - VkDeviceSize srcOffset; // Specified in bytes - VkDeviceSize destOffset; // Specified in bytes - VkDeviceSize copySize; // Specified in bytes -} VkBufferCopy; - -typedef struct VkImageMemoryBindInfo_ -{ - VkImageSubresource subresource; - VkOffset3D offset; - VkExtent3D extent; -} VkImageMemoryBindInfo; - -typedef struct VkImageCopy_ -{ - VkImageSubresource srcSubresource; - VkOffset3D srcOffset; // Specified in pixels for both compressed and uncompressed images - VkImageSubresource destSubresource; - VkOffset3D destOffset; // Specified in pixels for both compressed and uncompressed images - VkExtent3D extent; // Specified in pixels for both compressed and uncompressed images -} VkImageCopy; - -typedef struct VkImageBlit_ -{ - VkImageSubresource srcSubresource; - VkOffset3D srcOffset; // Specified in pixels for both compressed and uncompressed images - VkExtent3D srcExtent; // Specified in pixels for both compressed and uncompressed images - VkImageSubresource destSubresource; - VkOffset3D destOffset; // Specified in pixels for both compressed and uncompressed images - VkExtent3D destExtent; // Specified in pixels for both compressed and uncompressed images -} VkImageBlit; - -typedef struct VkBufferImageCopy_ -{ - VkDeviceSize bufferOffset; // Specified in bytes - VkImageSubresource imageSubresource; - VkOffset3D imageOffset; // Specified in pixels for both compressed and uncompressed images - VkExtent3D imageExtent; // Specified in pixels for both compressed and uncompressed images -} VkBufferImageCopy; - -typedef struct VkImageResolve_ -{ - VkImageSubresource srcSubresource; - VkOffset3D srcOffset; - VkImageSubresource destSubresource; - VkOffset3D destOffset; - VkExtent3D extent; -} VkImageResolve; - -typedef struct VkShaderCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO - const void* pNext; // Pointer to next structure - size_t codeSize; // Specified in bytes - const void* pCode; - VkShaderCreateFlags flags; // Reserved -} VkShaderCreateInfo; - -typedef struct VkDescriptorSetLayoutBinding_ -{ - VkDescriptorType descriptorType; // Type of the descriptors in this binding - uint32_t count; // Number of descriptors in this binding - VkShaderStageFlags stageFlags; // Shader stages this binding is visible to - const VkSampler* pImmutableSamplers; // Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains number of elements) -} VkDescriptorSetLayoutBinding; - -typedef struct VkDescriptorSetLayoutCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO - const void* pNext; // Pointer to next structure - uint32_t count; // Number of bindings in the descriptor set layout - const VkDescriptorSetLayoutBinding* pBinding; // Array of descriptor set layout bindings -} VkDescriptorSetLayoutCreateInfo; - -typedef struct VkDescriptorTypeCount_ -{ - VkDescriptorType type; - uint32_t count; -} VkDescriptorTypeCount; - -typedef struct VkDescriptorPoolCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO - const void* pNext; // Pointer to next structure - uint32_t count; - const VkDescriptorTypeCount* pTypeCount; -} VkDescriptorPoolCreateInfo; - -typedef struct VkLinkConstBuffer_ -{ - uint32_t bufferId; - size_t bufferSize; - const void* pBufferData; -} VkLinkConstBuffer; - -typedef struct VkSpecializationMapEntry_ -{ - uint32_t constantId; // The SpecConstant ID specified in the BIL - uint32_t offset; // Offset of the value in the data block -} VkSpecializationMapEntry; - -typedef struct VkSpecializationInfo_ -{ - uint32_t mapEntryCount; - const VkSpecializationMapEntry* pMap; // mapEntryCount entries - const void* pData; -} VkSpecializationInfo; - -typedef struct VkPipelineShader_ -{ - VkShaderStage stage; - VkShader shader; - uint32_t linkConstBufferCount; - const VkLinkConstBuffer* pLinkConstBufferInfo; - const VkSpecializationInfo* pSpecializationInfo; -} VkPipelineShader; - -typedef struct VkComputePipelineCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO - const void* pNext; // Pointer to next structure - VkPipelineShader cs; - VkPipelineCreateFlags flags; // Pipeline creation flags - VkPipelineLayout layout; // Interface layout of the pipeline -} VkComputePipelineCreateInfo; - -typedef struct VkVertexInputBindingDescription_ -{ - uint32_t binding; // Vertex buffer binding id - uint32_t strideInBytes; // Distance between vertices in bytes (0 = no advancement) - - VkVertexInputStepRate stepRate; // Rate at which binding is incremented -} VkVertexInputBindingDescription; - -typedef struct VkVertexInputAttributeDescription_ -{ - uint32_t location; // location of the shader vertex attrib - uint32_t binding; // Vertex buffer binding id - - VkFormat format; // format of source data - - uint32_t offsetInBytes; // Offset of first element in bytes from base of vertex -} VkVertexInputAttributeDescription; - -typedef struct VkPipelineVertexInputCreateInfo_ -{ - VkStructureType sType; // Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO - const void* pNext; // Pointer to next structure - - uint32_t bindingCount; // number of bindings - const VkVertexInputBindingDescription* pVertexBindingDescriptions; - - uint32_t attributeCount; // number of attributes - const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; -} VkPipelineVertexInputCreateInfo; - -typedef struct VkPipelineIaStateCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO - const void* pNext; // Pointer to next structure - VkPrimitiveTopology topology; - bool32_t disableVertexReuse; // optional - bool32_t primitiveRestartEnable; - uint32_t primitiveRestartIndex; // optional (GL45) -} VkPipelineIaStateCreateInfo; - -typedef struct VkPipelineTessStateCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO - const void* pNext; // Pointer to next structure - uint32_t patchControlPoints; -} VkPipelineTessStateCreateInfo; - -typedef struct VkPipelineVpStateCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO - const void* pNext; // Pointer to next structure - uint32_t viewportCount; - VkCoordinateOrigin clipOrigin; // optional (GL45) - VkDepthMode depthMode; // optional (GL45) -} VkPipelineVpStateCreateInfo; - -typedef struct VkPipelineRsStateCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO - const void* pNext; // Pointer to next structure - bool32_t depthClipEnable; - bool32_t rasterizerDiscardEnable; - bool32_t programPointSize; // optional (GL45) - VkCoordinateOrigin pointOrigin; // optional (GL45) - VkProvokingVertex provokingVertex; // optional (GL45) - VkFillMode fillMode; // optional (GL45) - VkCullMode cullMode; - VkFrontFace frontFace; -} VkPipelineRsStateCreateInfo; - -typedef struct VkPipelineMsStateCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO - const void* pNext; // Pointer to next structure - uint32_t samples; - bool32_t multisampleEnable; // optional (GL45) - bool32_t sampleShadingEnable; // optional (GL45) - float minSampleShading; // optional (GL45) - VkSampleMask sampleMask; -} VkPipelineMsStateCreateInfo; - -typedef struct VkPipelineCbAttachmentState_ -{ - bool32_t blendEnable; - VkFormat format; - VkBlend srcBlendColor; - VkBlend destBlendColor; - VkBlendOp blendOpColor; - VkBlend srcBlendAlpha; - VkBlend destBlendAlpha; - VkBlendOp blendOpAlpha; - VkChannelFlags channelWriteMask; -} VkPipelineCbAttachmentState; - -typedef struct VkPipelineCbStateCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO - const void* pNext; // Pointer to next structure - bool32_t alphaToCoverageEnable; - bool32_t logicOpEnable; - VkLogicOp logicOp; - uint32_t attachmentCount; // # of pAttachments - const VkPipelineCbAttachmentState* pAttachments; -} VkPipelineCbStateCreateInfo; - -typedef struct VkStencilOpState_ -{ - VkStencilOp stencilFailOp; - VkStencilOp stencilPassOp; - VkStencilOp stencilDepthFailOp; - VkCompareOp stencilCompareOp; -} VkStencilOpState; - -typedef struct VkPipelineDsStateCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO - const void* pNext; // Pointer to next structure - VkFormat format; - bool32_t depthTestEnable; - bool32_t depthWriteEnable; - VkCompareOp depthCompareOp; - bool32_t depthBoundsEnable; // optional (depth_bounds_test) - bool32_t stencilTestEnable; - VkStencilOpState front; - VkStencilOpState back; -} VkPipelineDsStateCreateInfo; - -typedef struct VkPipelineShaderStageCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO - const void* pNext; // Pointer to next structure - VkPipelineShader shader; -} VkPipelineShaderStageCreateInfo; - -typedef struct VkGraphicsPipelineCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO - const void* pNext; // Pointer to next structure - VkPipelineCreateFlags flags; // Pipeline creation flags - VkPipelineLayout layout; // Interface layout of the pipeline -} VkGraphicsPipelineCreateInfo; - -typedef struct VkPipelineLayoutCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO - const void* pNext; // Pointer to next structure - - uint32_t descriptorSetCount; // Number of descriptor sets interfaced by the pipeline - const VkDescriptorSetLayout* pSetLayouts; // Array of number of descriptor set layout objects defining the layout of the -} VkPipelineLayoutCreateInfo; - -typedef struct VkSamplerCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO - const void* pNext; // Pointer to next structure - VkTexFilter magFilter; // Filter mode for magnification - VkTexFilter minFilter; // Filter mode for minifiation - VkTexMipmapMode mipMode; // Mipmap selection mode - VkTexAddress addressU; - VkTexAddress addressV; - VkTexAddress addressW; - float mipLodBias; - uint32_t maxAnisotropy; - VkCompareOp compareOp; - float minLod; - float maxLod; - VkBorderColor borderColor; -} VkSamplerCreateInfo; - -typedef struct VkDynamicVpStateCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO - const void* pNext; // Pointer to next structure - uint32_t viewportAndScissorCount; // number of entries in pViewports and pScissors - const VkViewport* pViewports; - const VkRect* pScissors; -} VkDynamicVpStateCreateInfo; - -typedef struct VkDynamicRsStateCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO - const void* pNext; // Pointer to next structure - float depthBias; - float depthBiasClamp; - float slopeScaledDepthBias; - float pointSize; // optional (GL45) - Size of points - float pointFadeThreshold; // optional (GL45) - Size of point fade threshold - float lineWidth; // optional (GL45) - Width of lines -} VkDynamicRsStateCreateInfo; - -typedef struct VkDynamicCbStateCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO - const void* pNext; // Pointer to next structure - float blendConst[4]; -} VkDynamicCbStateCreateInfo; - -typedef struct VkDynamicDsStateCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO - const void* pNext; // Pointer to next structure - float minDepth; // optional (depth_bounds_test) - float maxDepth; // optional (depth_bounds_test) - uint32_t stencilReadMask; - uint32_t stencilWriteMask; - uint32_t stencilFrontRef; - uint32_t stencilBackRef; -} VkDynamicDsStateCreateInfo; - -typedef struct VkCmdBufferCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO - const void* pNext; // Pointer to next structure - uint32_t queueNodeIndex; - VkCmdBufferCreateFlags flags; // Command buffer creation flags -} VkCmdBufferCreateInfo; - -typedef struct VkCmdBufferBeginInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO - const void* pNext; // Pointer to next structure - - VkCmdBufferOptimizeFlags flags; // Command buffer optimization flags -} VkCmdBufferBeginInfo; - -typedef struct VkRenderPassBegin_ -{ - VkRenderPass renderPass; - VkFramebuffer framebuffer; -} VkRenderPassBegin; - -typedef struct VkCmdBufferGraphicsBeginInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO - const void* pNext; // Pointer to next structure - - VkRenderPassBegin renderPassContinue; // Only needed when a render pass is split across two command buffers -} VkCmdBufferGraphicsBeginInfo; - -// Union allowing specification of floating point or raw color data. Actual value selected is based on image being cleared. -typedef union VkClearColorValue_ -{ - float floatColor[4]; - uint32_t rawColor[4]; -} VkClearColorValue; - -typedef struct VkClearColor_ -{ - VkClearColorValue color; - bool32_t useRawValue; -} VkClearColor; - -typedef struct VkRenderPassCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO - const void* pNext; // Pointer to next structure - - VkRect renderArea; - uint32_t colorAttachmentCount; - VkExtent2D extent; - uint32_t sampleCount; - uint32_t layers; - const VkFormat* pColorFormats; - const VkImageLayout* pColorLayouts; - const VkAttachmentLoadOp* pColorLoadOps; - const VkAttachmentStoreOp* pColorStoreOps; - const VkClearColor* pColorLoadClearValues; - VkFormat depthStencilFormat; - VkImageLayout depthStencilLayout; - VkAttachmentLoadOp depthLoadOp; - float depthLoadClearValue; - VkAttachmentStoreOp depthStoreOp; - VkAttachmentLoadOp stencilLoadOp; - uint32_t stencilLoadClearValue; - VkAttachmentStoreOp stencilStoreOp; -} VkRenderPassCreateInfo; - -typedef struct VkEventCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO - const void* pNext; // Pointer to next structure - VkEventCreateFlags flags; // Event creation flags -} VkEventCreateInfo; - -typedef struct VkFenceCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO - const void* pNext; // Pointer to next structure - VkFenceCreateFlags flags; // Fence creation flags -} VkFenceCreateInfo; - -typedef struct VkSemaphoreCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO - const void* pNext; // Pointer to next structure - uint32_t initialCount; - VkSemaphoreCreateFlags flags; // Semaphore creation flags -} VkSemaphoreCreateInfo; - -typedef struct VkSemaphoreOpenInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO - const void* pNext; // Pointer to next structure - VkSemaphore sharedSemaphore; -} VkSemaphoreOpenInfo; - -typedef struct VkQueryPoolCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO - const void* pNext; // Pointer to next structure - VkQueryType queryType; - uint32_t slots; - VkQueryPipelineStatisticFlags pipelineStatistics; // Optional -} VkQueryPoolCreateInfo; - -typedef struct VkFramebufferCreateInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO - const void* pNext; // Pointer to next structure - - uint32_t colorAttachmentCount; - const VkColorAttachmentBindInfo* pColorAttachments; - const VkDepthStencilBindInfo* pDepthStencilAttachment; - - uint32_t sampleCount; - uint32_t width; - uint32_t height; - uint32_t layers; -} VkFramebufferCreateInfo; - -typedef struct VkDrawIndirectCmd_ -{ - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; -} VkDrawIndirectCmd; - -typedef struct VkDrawIndexedIndirectCmd_ -{ - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VkDrawIndexedIndirectCmd; - -typedef struct VkDispatchIndirectCmd_ -{ - uint32_t x; - uint32_t y; - uint32_t z; -} VkDispatchIndirectCmd; - -// ------------------------------------------------------------------------------------------------ -// API functions -typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); -typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); -typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceInfo)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, size_t* pDataSize, void* pData); -typedef void * (VKAPI *PFN_vkGetProcAddr)(VkPhysicalDevice physicalDevice, const char * pName); -typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); -typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device); -typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionInfo)(VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionInfo)(VkPhysicalDevice physicalDevice, VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalDevice physicalDevice, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved); -typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue); -typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence); -typedef VkResult (VKAPI *PFN_vkQueueAddMemReferences)(VkQueue queue, uint32_t count, const VkDeviceMemory* pMems); -typedef VkResult (VKAPI *PFN_vkQueueRemoveMemReferences)(VkQueue queue, uint32_t count, const VkDeviceMemory* pMems); -typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); -typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); -typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); -typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem); -typedef VkResult (VKAPI *PFN_vkSetMemoryPriority)(VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority); -typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); -typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem); -typedef VkResult (VKAPI *PFN_vkFlushMappedMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size); -typedef VkResult (VKAPI *PFN_vkPinSystemMemory)(VkDevice device, const void* pSysMem, size_t memSize, VkDeviceMemory* pMem); -typedef VkResult (VKAPI *PFN_vkGetMultiDeviceCompatibility)(VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo); -typedef VkResult (VKAPI *PFN_vkOpenSharedMemory)(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem); -typedef VkResult (VKAPI *PFN_vkOpenSharedSemaphore)(VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore); -typedef VkResult (VKAPI *PFN_vkOpenPeerMemory)(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem); -typedef VkResult (VKAPI *PFN_vkOpenPeerImage)(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem); -typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkDevice device, VkObjectType objType, VkObject object); -typedef VkResult (VKAPI *PFN_vkGetObjectInfo)(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemory)(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset); -typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemoryRange)(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset); -typedef VkResult (VKAPI *PFN_vkQueueBindImageMemoryRange)(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset); -typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); -typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, VkFence* pFences); -typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); -typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout); -typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore); -typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore); -typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore); -typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent); -typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); -typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); -typedef VkResult (VKAPI *PFN_vkGetFormatInfo)(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); -typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); -typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage); -typedef VkResult (VKAPI *PFN_vkGetImageSubresourceInfo)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); -typedef VkResult (VKAPI *PFN_vkCreateColorAttachmentView)(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView); -typedef VkResult (VKAPI *PFN_vkCreateDepthStencilView)(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView); -typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); -typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipeline)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline); -typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelineDerivative)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline); -typedef VkResult (VKAPI *PFN_vkCreateComputePipeline)(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline); -typedef VkResult (VKAPI *PFN_vkStorePipeline)(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkLoadPipeline)(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline); -typedef VkResult (VKAPI *PFN_vkLoadPipelineDerivative)(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline); -typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); -typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); -typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); -typedef VkResult (VKAPI *PFN_vkBeginDescriptorPoolUpdate)(VkDevice device, VkDescriptorUpdateMode updateMode); -typedef VkResult (VKAPI *PFN_vkEndDescriptorPoolUpdate)(VkDevice device, VkCmdBuffer cmd); -typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); -typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); -typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount); -typedef void (VKAPI *PFN_vkClearDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); -typedef void (VKAPI *PFN_vkUpdateDescriptors)(VkDevice device, VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray); -typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState); -typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer); -typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo); -typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); -typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer); -typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef void (VKAPI *PFN_vkCmdBindDynamicStateObject)(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state); -typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); -typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); -typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); -typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); -typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); -typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); -typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); -typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); -typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset); -typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions); -typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdCloneImageData)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout); -typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData); -typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data); -typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI *PFN_vkCmdClearDepthStencil)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); -typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent); -typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent); -typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, uint32_t memBarrierCount, const void** ppMemBarriers); -typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers); -typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); -typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot); -typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); -typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset); -typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags); -typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); -typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); -typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin); -typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer, VkRenderPass renderPass); - -#ifdef VK_PROTOTYPES -VkResult VKAPI vkCreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - VkInstance* pInstance); - -VkResult VKAPI vkDestroyInstance( - VkInstance instance); - -VkResult VKAPI vkEnumeratePhysicalDevices( - VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices); - -VkResult VKAPI vkGetPhysicalDeviceInfo( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceInfoType infoType, - size_t* pDataSize, - void* pData); - -void * VKAPI vkGetProcAddr( - VkPhysicalDevice physicalDevice, - const char* pName); - -// Device functions - -VkResult VKAPI vkCreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - VkDevice* pDevice); - -VkResult VKAPI vkDestroyDevice( - VkDevice device); - -VkResult VKAPI vkGetGlobalExtensionInfo( - VkExtensionInfoType infoType, - uint32_t extensionIndex, - size_t* pDataSize, - void* pData); - -VkResult VKAPI vkGetPhysicalDeviceExtensionInfo( - VkPhysicalDevice physicalDevice, - VkExtensionInfoType infoType, - uint32_t extensionIndex, - size_t* pDataSize, - void* pData); - -VkResult VKAPI vkEnumerateLayers( - VkPhysicalDevice physicalDevice, - size_t maxStringSize, - size_t* pLayerCount, - char* const* pOutLayers, - void* pReserved); - -VkResult VKAPI vkGetDeviceQueue( - VkDevice device, - uint32_t queueNodeIndex, - uint32_t queueIndex, - VkQueue* pQueue); - -VkResult VKAPI vkQueueSubmit( - VkQueue queue, - uint32_t cmdBufferCount, - const VkCmdBuffer* pCmdBuffers, - VkFence fence); - -VkResult VKAPI vkQueueAddMemReferences( - VkQueue queue, - uint32_t count, - const VkDeviceMemory* pMems); - -VkResult VKAPI vkQueueRemoveMemReferences( - VkQueue queue, - uint32_t count, - const VkDeviceMemory* pMems); - -VkResult VKAPI vkQueueWaitIdle( - VkQueue queue); - -VkResult VKAPI vkDeviceWaitIdle( - VkDevice device); - -VkResult VKAPI vkAllocMemory( - VkDevice device, - const VkMemoryAllocInfo* pAllocInfo, - VkDeviceMemory* pMem); - -VkResult VKAPI vkFreeMemory( - VkDevice device, - VkDeviceMemory mem); - -VkResult VKAPI vkSetMemoryPriority( - VkDevice device, - VkDeviceMemory mem, - VkMemoryPriority priority); - -VkResult VKAPI vkMapMemory( - VkDevice device, - VkDeviceMemory mem, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData); - -VkResult VKAPI vkUnmapMemory( - VkDevice device, - VkDeviceMemory mem); - -VkResult VKAPI vkFlushMappedMemory( - VkDevice device, - VkDeviceMemory mem, - VkDeviceSize offset, - VkDeviceSize size); - -VkResult VKAPI vkPinSystemMemory( - VkDevice device, - const void* pSysMem, - size_t memSize, - VkDeviceMemory* pMem); - -VkResult VKAPI vkGetMultiDeviceCompatibility( - VkPhysicalDevice physicalDevice0, - VkPhysicalDevice physicalDevice1, - VkPhysicalDeviceCompatibilityInfo* pInfo); - -VkResult VKAPI vkOpenSharedMemory( - VkDevice device, - const VkMemoryOpenInfo* pOpenInfo, - VkDeviceMemory* pMem); - -VkResult VKAPI vkOpenSharedSemaphore( - VkDevice device, - const VkSemaphoreOpenInfo* pOpenInfo, - VkSemaphore* pSemaphore); - -VkResult VKAPI vkOpenPeerMemory( - VkDevice device, - const VkPeerMemoryOpenInfo* pOpenInfo, - VkDeviceMemory* pMem); - -VkResult VKAPI vkOpenPeerImage( - VkDevice device, - const VkPeerImageOpenInfo* pOpenInfo, - VkImage* pImage, - VkDeviceMemory* pMem); - -VkResult VKAPI vkDestroyObject( - VkDevice device, - VkObjectType objType, - VkObject object); - -VkResult VKAPI vkGetObjectInfo( - VkDevice device, - VkObjectType objType, - VkObject object, - VkObjectInfoType infoType, - size_t* pDataSize, - void* pData); - -VkResult VKAPI vkQueueBindObjectMemory( - VkQueue queue, - VkObjectType objType, - VkObject object, - uint32_t allocationIdx, - VkDeviceMemory mem, - VkDeviceSize memOffset); - -VkResult VKAPI vkQueueBindObjectMemoryRange( - VkQueue queue, - VkObjectType objType, - VkObject object, - uint32_t allocationIdx, - VkDeviceSize rangeOffset, - VkDeviceSize rangeSize, - VkDeviceMemory mem, - VkDeviceSize memOffset); - -VkResult VKAPI vkQueueBindImageMemoryRange( - VkQueue queue, - VkImage image, - uint32_t allocationIdx, - const VkImageMemoryBindInfo* pBindInfo, - VkDeviceMemory mem, - VkDeviceSize memOffset); - -VkResult VKAPI vkCreateFence( - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - VkFence* pFence); - -VkResult VKAPI vkResetFences( - VkDevice device, - uint32_t fenceCount, - VkFence* pFences); - -VkResult VKAPI vkGetFenceStatus( - VkDevice device, - VkFence fence); - -VkResult VKAPI vkWaitForFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences, - bool32_t waitAll, - uint64_t timeout); // timeout in nanoseconds - -VkResult VKAPI vkCreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - VkSemaphore* pSemaphore); - -VkResult VKAPI vkQueueSignalSemaphore( - VkQueue queue, - VkSemaphore semaphore); - -VkResult VKAPI vkQueueWaitSemaphore( - VkQueue queue, - VkSemaphore semaphore); - -VkResult VKAPI vkCreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - VkEvent* pEvent); - -VkResult VKAPI vkGetEventStatus( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkSetEvent( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkResetEvent( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkCreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - VkQueryPool* pQueryPool); - -VkResult VKAPI vkGetQueryPoolResults( - VkDevice device, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount, - size_t* pDataSize, - void* pData, - VkQueryResultFlags flags); - -VkResult VKAPI vkGetFormatInfo( - VkDevice device, - VkFormat format, - VkFormatInfoType infoType, - size_t* pDataSize, - void* pData); - -VkResult VKAPI vkCreateBuffer( - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - VkBuffer* pBuffer); - -VkResult VKAPI vkCreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - VkBufferView* pView); - -VkResult VKAPI vkCreateImage( - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - VkImage* pImage); - -VkResult VKAPI vkGetImageSubresourceInfo( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceInfoType infoType, - size_t* pDataSize, - void* pData); - -// Image view functions - -VkResult VKAPI vkCreateImageView( - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - VkImageView* pView); - -VkResult VKAPI vkCreateColorAttachmentView( - VkDevice device, - const VkColorAttachmentViewCreateInfo* pCreateInfo, - VkColorAttachmentView* pView); - -VkResult VKAPI vkCreateDepthStencilView( - VkDevice device, - const VkDepthStencilViewCreateInfo* pCreateInfo, - VkDepthStencilView* pView); - -VkResult VKAPI vkCreateShader( - VkDevice device, - const VkShaderCreateInfo* pCreateInfo, - VkShader* pShader); - -VkResult VKAPI vkCreateGraphicsPipeline( - VkDevice device, - const VkGraphicsPipelineCreateInfo* pCreateInfo, - VkPipeline* pPipeline); - -VkResult VKAPI vkCreateGraphicsPipelineDerivative( - VkDevice device, - const VkGraphicsPipelineCreateInfo* pCreateInfo, - VkPipeline basePipeline, - VkPipeline* pPipeline); - -VkResult VKAPI vkCreateComputePipeline( - VkDevice device, - const VkComputePipelineCreateInfo* pCreateInfo, - VkPipeline* pPipeline); - -VkResult VKAPI vkStorePipeline( - VkDevice device, - VkPipeline pipeline, - size_t* pDataSize, - void* pData); - -VkResult VKAPI vkLoadPipeline( - VkDevice device, - size_t dataSize, - const void* pData, - VkPipeline* pPipeline); - -VkResult VKAPI vkLoadPipelineDerivative( - VkDevice device, - size_t dataSize, - const void* pData, - VkPipeline basePipeline, - VkPipeline* pPipeline); - -VkResult VKAPI vkCreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - VkPipelineLayout* pPipelineLayout); - -VkResult VKAPI vkCreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - VkSampler* pSampler); - -VkResult VKAPI vkCreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayout* pSetLayout); - -VkResult VKAPI vkBeginDescriptorPoolUpdate( - VkDevice device, - VkDescriptorUpdateMode updateMode); - -VkResult VKAPI vkEndDescriptorPoolUpdate( - VkDevice device, - VkCmdBuffer cmd); - -VkResult VKAPI vkCreateDescriptorPool( - VkDevice device, - VkDescriptorPoolUsage poolUsage, - uint32_t maxSets, - const VkDescriptorPoolCreateInfo* pCreateInfo, - VkDescriptorPool* pDescriptorPool); - -VkResult VKAPI vkResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool); - -VkResult VKAPI vkAllocDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorSetUsage setUsage, - uint32_t count, - const VkDescriptorSetLayout* pSetLayouts, - VkDescriptorSet* pDescriptorSets, - uint32_t* pCount); - -void VKAPI vkClearDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t count, - const VkDescriptorSet* pDescriptorSets); - -void VKAPI vkUpdateDescriptors( - VkDevice device, - VkDescriptorSet descriptorSet, - uint32_t updateCount, - const void** ppUpdateArray); - -VkResult VKAPI vkCreateDynamicViewportState( - VkDevice device, - const VkDynamicVpStateCreateInfo* pCreateInfo, - VkDynamicVpState* pState); - -VkResult VKAPI vkCreateDynamicRasterState( - VkDevice device, - const VkDynamicRsStateCreateInfo* pCreateInfo, - VkDynamicRsState* pState); - -VkResult VKAPI vkCreateDynamicColorBlendState( - VkDevice device, - const VkDynamicCbStateCreateInfo* pCreateInfo, - VkDynamicCbState* pState); - -VkResult VKAPI vkCreateDynamicDepthStencilState( - VkDevice device, - const VkDynamicDsStateCreateInfo* pCreateInfo, - VkDynamicDsState* pState); - -VkResult VKAPI vkCreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - VkFramebuffer* pFramebuffer); - -VkResult VKAPI vkCreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - VkRenderPass* pRenderPass); - -VkResult VKAPI vkCreateCommandBuffer( - VkDevice device, - const VkCmdBufferCreateInfo* pCreateInfo, - VkCmdBuffer* pCmdBuffer); - -VkResult VKAPI vkBeginCommandBuffer( - VkCmdBuffer cmdBuffer, - const VkCmdBufferBeginInfo* pBeginInfo); - -VkResult VKAPI vkEndCommandBuffer( - VkCmdBuffer cmdBuffer); - -VkResult VKAPI vkResetCommandBuffer( - VkCmdBuffer cmdBuffer); - -void VKAPI vkCmdBindPipeline( - VkCmdBuffer cmdBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); - -void VKAPI vkCmdBindDynamicStateObject( - VkCmdBuffer cmdBuffer, - VkStateBindPoint stateBindPoint, - VkDynamicStateObject dynamicState); - -void VKAPI vkCmdBindDescriptorSets( - VkCmdBuffer cmdBuffer, - VkPipelineBindPoint pipelineBindPoint, - uint32_t firstSet, - uint32_t setCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets); - -void VKAPI vkCmdBindIndexBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType); - -void VKAPI vkCmdBindVertexBuffers( - VkCmdBuffer cmdBuffer, - uint32_t startBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets); - -void VKAPI vkCmdDraw( - VkCmdBuffer cmdBuffer, - uint32_t firstVertex, - uint32_t vertexCount, - uint32_t firstInstance, - uint32_t instanceCount); - -void VKAPI vkCmdDrawIndexed( - VkCmdBuffer cmdBuffer, - uint32_t firstIndex, - uint32_t indexCount, - int32_t vertexOffset, - uint32_t firstInstance, - uint32_t instanceCount); - -void VKAPI vkCmdDrawIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDrawIndexedIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDispatch( - VkCmdBuffer cmdBuffer, - uint32_t x, - uint32_t y, - uint32_t z); - -void VKAPI vkCmdDispatchIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset); - -void VKAPI vkCmdCopyBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer srcBuffer, - VkBuffer destBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions); - -void VKAPI vkCmdCopyImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions); - -void VKAPI vkCmdBlitImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions); - -void VKAPI vkCmdCopyBufferToImage( - VkCmdBuffer cmdBuffer, - VkBuffer srcBuffer, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -void VKAPI vkCmdCopyImageToBuffer( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer destBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -void VKAPI vkCmdCloneImageData( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout); - -void VKAPI vkCmdUpdateBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize dataSize, - const uint32_t* pData); - -void VKAPI vkCmdFillBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize fillSize, - uint32_t data); - -void VKAPI vkCmdClearColorImage( - VkCmdBuffer cmdBuffer, - VkImage image, - VkImageLayout imageLayout, - VkClearColor color, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -void VKAPI vkCmdClearDepthStencil( - VkCmdBuffer cmdBuffer, - VkImage image, - VkImageLayout imageLayout, - float depth, - uint32_t stencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -void VKAPI vkCmdResolveImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions); - -void VKAPI vkCmdSetEvent( - VkCmdBuffer cmdBuffer, - VkEvent event, - VkPipeEvent pipeEvent); - -void VKAPI vkCmdResetEvent( - VkCmdBuffer cmdBuffer, - VkEvent event, - VkPipeEvent pipeEvent); - -void VKAPI vkCmdWaitEvents( - VkCmdBuffer cmdBuffer, - VkWaitEvent waitEvent, - uint32_t eventCount, - const VkEvent* pEvents, - uint32_t memBarrierCount, - const void** ppMemBarriers); - -void VKAPI vkCmdPipelineBarrier( - VkCmdBuffer cmdBuffer, - VkWaitEvent waitEvent, - uint32_t pipeEventCount, - const VkPipeEvent* pPipeEvents, - uint32_t memBarrierCount, - const void** ppMemBarriers); - -void VKAPI vkCmdBeginQuery( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t slot, - VkQueryControlFlags flags); - -void VKAPI vkCmdEndQuery( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t slot); - -void VKAPI vkCmdResetQueryPool( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount); - -void VKAPI vkCmdWriteTimestamp( - VkCmdBuffer cmdBuffer, - VkTimestampType timestampType, - VkBuffer destBuffer, - VkDeviceSize destOffset); - -void VKAPI vkCmdCopyQueryPoolResults( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize destStride, - VkQueryResultFlags flags); - -void VKAPI vkCmdBeginRenderPass( - VkCmdBuffer cmdBuffer, - const VkRenderPassBegin* pRenderPassBegin); - -void VKAPI vkCmdEndRenderPass( - VkCmdBuffer cmdBuffer, - VkRenderPass renderPass); - -#endif - -#ifdef __cplusplus -} -#endif - -#endif