From e1091caa24131fae2d101968a056e82cb349f476 Mon Sep 17 00:00:00 2001 From: Bergmann89 Date: Mon, 14 Mar 2016 20:23:08 +0100 Subject: [PATCH] * implemented vkuSwapChain and vkuSwapChainFactory --- data/vulkan.tpl | 1 + projects/Vulkan.pas | 2566 +++++++++++++---------- projects/generator/HeaderGenerator.pas | 167 +- projects/generator/generator.lps | 129 +- projects/triangle/triangle.lpi | 10 +- projects/triangle/triangle.lpr | 2 +- projects/triangle/triangle.lps | 337 +-- projects/triangle/uMainForm.pas | 94 +- projects/utils/uvkuDevice.pas | 7 +- projects/utils/uvkuDeviceFactory.pas | 21 +- projects/utils/uvkuInstance.pas | 2 +- projects/utils/uvkuInstanceFactory.pas | 22 - projects/utils/uvkuPhysicalDevice.pas | 62 +- projects/utils/uvkuSurface.pas | 24 +- projects/utils/uvkuSurfaceFactory.pas | 19 +- projects/utils/uvkuSwapChain.pas | 130 ++ projects/utils/uvkuSwapChainFactory.pas | 178 ++ projects/utils/uvkuUtils.pas | 22 +- 18 files changed, 2317 insertions(+), 1476 deletions(-) create mode 100644 projects/utils/uvkuSwapChain.pas create mode 100644 projects/utils/uvkuSwapChainFactory.pas diff --git a/data/vulkan.tpl b/data/vulkan.tpl index 2f110be..8966721 100644 --- a/data/vulkan.tpl +++ b/data/vulkan.tpl @@ -27,6 +27,7 @@ unit Vulkan; {$LINKLIB c} {$ENDIF} {$MINENUMSIZE 4} + {$PACKSET 4} {$ENDIF} {$I Vulkan.inc} diff --git a/projects/Vulkan.pas b/projects/Vulkan.pas index 8eab3e0..4ede61a 100644 --- a/projects/Vulkan.pas +++ b/projects/Vulkan.pas @@ -57,6 +57,7 @@ unit Vulkan; {$LINKLIB c} {$ENDIF} {$MINENUMSIZE 4} + {$PACKSET 4} {$ENDIF} {$I Vulkan.inc} @@ -195,1271 +196,1526 @@ const VK_EXT_DEBUG_REPORT_SPEC_VERSION = 1; VK_EXT_DEBUG_REPORT_EXTENSION_NAME = 'VK_EXT_debug_report'; -type { simple types } +type { enumerations } { ========================================== VK_VERSION_1_0 ========================================== } - VkFlags = VkUint32; - PVkFlags = ^VkFlags; - PPVkFlags = ^PVkFlags; - - VkInstanceCreateFlags = VkFlags; - PVkInstanceCreateFlags = ^VkInstanceCreateFlags; - PPVkInstanceCreateFlags = ^PVkInstanceCreateFlags; - - _VkInstance = record end; - VkInstance = ^_VkInstance; - PVkInstance = ^VkInstance; - PPVkInstance = ^PVkInstance; - - _VkPhysicalDevice = record end; - VkPhysicalDevice = ^_VkPhysicalDevice; - PVkPhysicalDevice = ^VkPhysicalDevice; - PPVkPhysicalDevice = ^PVkPhysicalDevice; - - VkBool32 = VkUint32; - PVkBool32 = ^VkBool32; - PPVkBool32 = ^PVkBool32; - - VkFormatFeatureFlags = VkFlags; - PVkFormatFeatureFlags = ^VkFormatFeatureFlags; - PPVkFormatFeatureFlags = ^PVkFormatFeatureFlags; - - VkImageUsageFlags = VkFlags; - PVkImageUsageFlags = ^VkImageUsageFlags; - PPVkImageUsageFlags = ^PVkImageUsageFlags; - - VkImageCreateFlags = VkFlags; - PVkImageCreateFlags = ^VkImageCreateFlags; - PPVkImageCreateFlags = ^PVkImageCreateFlags; - - VkSampleCountFlags = VkFlags; - PVkSampleCountFlags = ^VkSampleCountFlags; - PPVkSampleCountFlags = ^PVkSampleCountFlags; - - VkDeviceSize = VkUint64; - PVkDeviceSize = ^VkDeviceSize; - PPVkDeviceSize = ^PVkDeviceSize; - - VkQueueFlags = VkFlags; - PVkQueueFlags = ^VkQueueFlags; - PPVkQueueFlags = ^PVkQueueFlags; - - VkMemoryPropertyFlags = VkFlags; - PVkMemoryPropertyFlags = ^VkMemoryPropertyFlags; - PPVkMemoryPropertyFlags = ^PVkMemoryPropertyFlags; - - VkMemoryHeapFlags = VkFlags; - PVkMemoryHeapFlags = ^VkMemoryHeapFlags; - PPVkMemoryHeapFlags = ^PVkMemoryHeapFlags; - - _VkDevice = record end; - VkDevice = ^_VkDevice; - PVkDevice = ^VkDevice; - PPVkDevice = ^PVkDevice; - - VkDeviceCreateFlags = VkFlags; - PVkDeviceCreateFlags = ^VkDeviceCreateFlags; - PPVkDeviceCreateFlags = ^PVkDeviceCreateFlags; - - VkDeviceQueueCreateFlags = VkFlags; - PVkDeviceQueueCreateFlags = ^VkDeviceQueueCreateFlags; - PPVkDeviceQueueCreateFlags = ^PVkDeviceQueueCreateFlags; - - _VkQueue = record end; - VkQueue = ^_VkQueue; - PVkQueue = ^VkQueue; - PPVkQueue = ^PVkQueue; - - _VkSemaphore = record end; - VkSemaphore = {$IFDEF VK_CPU64}^_VkSemaphore{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkSemaphore = ^VkSemaphore; - PPVkSemaphore = ^PVkSemaphore; - - VkPipelineStageFlags = VkFlags; - PVkPipelineStageFlags = ^VkPipelineStageFlags; - PPVkPipelineStageFlags = ^PVkPipelineStageFlags; - - _VkCommandPool = record end; - VkCommandPool = {$IFDEF VK_CPU64}^_VkCommandPool{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkCommandPool = ^VkCommandPool; - PPVkCommandPool = ^PVkCommandPool; - - _VkCommandBuffer = record end; - VkCommandBuffer = ^_VkCommandBuffer; - PVkCommandBuffer = ^VkCommandBuffer; - PPVkCommandBuffer = ^PVkCommandBuffer; - - _VkFence = record end; - VkFence = {$IFDEF VK_CPU64}^_VkFence{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkFence = ^VkFence; - PPVkFence = ^PVkFence; - - _VkDeviceMemory = record end; - VkDeviceMemory = {$IFDEF VK_CPU64}^_VkDeviceMemory{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkDeviceMemory = ^VkDeviceMemory; - PPVkDeviceMemory = ^PVkDeviceMemory; - - VkMemoryMapFlags = VkFlags; - PVkMemoryMapFlags = ^VkMemoryMapFlags; - PPVkMemoryMapFlags = ^PVkMemoryMapFlags; - - _VkBuffer = record end; - VkBuffer = {$IFDEF VK_CPU64}^_VkBuffer{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkBuffer = ^VkBuffer; - PPVkBuffer = ^PVkBuffer; - - _VkImage = record end; - VkImage = {$IFDEF VK_CPU64}^_VkImage{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkImage = ^VkImage; - PPVkImage = ^PVkImage; - - VkImageAspectFlags = VkFlags; - PVkImageAspectFlags = ^VkImageAspectFlags; - PPVkImageAspectFlags = ^PVkImageAspectFlags; - - VkSparseImageFormatFlags = VkFlags; - PVkSparseImageFormatFlags = ^VkSparseImageFormatFlags; - PPVkSparseImageFormatFlags = ^PVkSparseImageFormatFlags; - - VkSparseMemoryBindFlags = VkFlags; - PVkSparseMemoryBindFlags = ^VkSparseMemoryBindFlags; - PPVkSparseMemoryBindFlags = ^PVkSparseMemoryBindFlags; - - VkFenceCreateFlags = VkFlags; - PVkFenceCreateFlags = ^VkFenceCreateFlags; - PPVkFenceCreateFlags = ^PVkFenceCreateFlags; - - VkSemaphoreCreateFlags = VkFlags; - PVkSemaphoreCreateFlags = ^VkSemaphoreCreateFlags; - PPVkSemaphoreCreateFlags = ^PVkSemaphoreCreateFlags; - - VkEventCreateFlags = VkFlags; - PVkEventCreateFlags = ^VkEventCreateFlags; - PPVkEventCreateFlags = ^PVkEventCreateFlags; + TVkPipelineCacheHeaderVersion = ( + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = $7FFFFFFF + ); + PVkPipelineCacheHeaderVersion = ^TVkPipelineCacheHeaderVersion; + PPVkPipelineCacheHeaderVersion = ^PVkPipelineCacheHeaderVersion; - _VkEvent = record end; - VkEvent = {$IFDEF VK_CPU64}^_VkEvent{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkEvent = ^VkEvent; - PPVkEvent = ^PVkEvent; + TVkResult = ( + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, + VK__MAX_ENUM = $7FFFFFFF + ); + PVkResult = ^TVkResult; + PPVkResult = ^PVkResult; - VkQueryPoolCreateFlags = VkFlags; - PVkQueryPoolCreateFlags = ^VkQueryPoolCreateFlags; - PPVkQueryPoolCreateFlags = ^PVkQueryPoolCreateFlags; + TVkStructureType = ( + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, + VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000, + VK_STRUCTURE_TYPE_MAX_ENUM = $7FFFFFFF + ); + PVkStructureType = ^TVkStructureType; + PPVkStructureType = ^PVkStructureType; - VkQueryPipelineStatisticFlags = VkFlags; - PVkQueryPipelineStatisticFlags = ^VkQueryPipelineStatisticFlags; - PPVkQueryPipelineStatisticFlags = ^PVkQueryPipelineStatisticFlags; + TVkSystemAllocationScope = ( + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = $7FFFFFFF + ); + PVkSystemAllocationScope = ^TVkSystemAllocationScope; + PPVkSystemAllocationScope = ^PVkSystemAllocationScope; - _VkQueryPool = record end; - VkQueryPool = {$IFDEF VK_CPU64}^_VkQueryPool{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkQueryPool = ^VkQueryPool; - PPVkQueryPool = ^PVkQueryPool; + TVkInternalAllocationType = ( + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = $7FFFFFFF + ); + PVkInternalAllocationType = ^TVkInternalAllocationType; + PPVkInternalAllocationType = ^PVkInternalAllocationType; - VkQueryResultFlags = VkFlags; - PVkQueryResultFlags = ^VkQueryResultFlags; - PPVkQueryResultFlags = ^PVkQueryResultFlags; + TVkFormat = ( + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_MAX_ENUM = $7FFFFFFF + ); + PVkFormat = ^TVkFormat; + PPVkFormat = ^PVkFormat; - VkBufferCreateFlags = VkFlags; - PVkBufferCreateFlags = ^VkBufferCreateFlags; - PPVkBufferCreateFlags = ^PVkBufferCreateFlags; + TVkFormatFeatureFlagBit = ( + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0, + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 1, + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 2, + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 3, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 4, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 5, + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 6, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 7, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 8, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 9, + VK_FORMAT_FEATURE_BLIT_SRC_BIT = 10, + VK_FORMAT_FEATURE_BLIT_DST_BIT = 11, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 12, + VK_FORMAT_FEATURE_MAX_BIT = 31 + ); + TVkFormatFeatureFlagBits = set of TVkFormatFeatureFlagBit; - VkBufferUsageFlags = VkFlags; - PVkBufferUsageFlags = ^VkBufferUsageFlags; - PPVkBufferUsageFlags = ^PVkBufferUsageFlags; + TVkImageType = ( + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_MAX_ENUM = $7FFFFFFF + ); + PVkImageType = ^TVkImageType; + PPVkImageType = ^PVkImageType; - VkBufferViewCreateFlags = VkFlags; - PVkBufferViewCreateFlags = ^VkBufferViewCreateFlags; - PPVkBufferViewCreateFlags = ^PVkBufferViewCreateFlags; + TVkImageTiling = ( + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_MAX_ENUM = $7FFFFFFF + ); + PVkImageTiling = ^TVkImageTiling; + PPVkImageTiling = ^PVkImageTiling; - _VkBufferView = record end; - VkBufferView = {$IFDEF VK_CPU64}^_VkBufferView{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkBufferView = ^VkBufferView; - PPVkBufferView = ^PVkBufferView; + TVkImageUsageFlagBit = ( + VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0, + VK_IMAGE_USAGE_TRANSFER_DST_BIT = 1, + VK_IMAGE_USAGE_SAMPLED_BIT = 2, + VK_IMAGE_USAGE_STORAGE_BIT = 3, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 4, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 5, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 6, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 7, + VK_IMAGE_USAGE_MAX_BIT = 31 + ); + TVkImageUsageFlagBits = set of TVkImageUsageFlagBit; + + TVkImageCreateFlagBit = ( + VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 1, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 2, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 3, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 4, + VK_IMAGE_CREATE_MAX_BIT = 31 + ); + TVkImageCreateFlagBits = set of TVkImageCreateFlagBit; + + TVkSampleCountFlagBit = ( + VK_SAMPLE_COUNT_1_BIT = 0, + VK_SAMPLE_COUNT_2_BIT = 1, + VK_SAMPLE_COUNT_4_BIT = 2, + VK_SAMPLE_COUNT_8_BIT = 3, + VK_SAMPLE_COUNT_16_BIT = 4, + VK_SAMPLE_COUNT_32_BIT = 5, + VK_SAMPLE_COUNT_64_BIT = 6, + VK_SAMPLE_COUNT_MAX_BIT = 31 + ); + TVkSampleCountFlagBits = set of TVkSampleCountFlagBit; - VkImageViewCreateFlags = VkFlags; - PVkImageViewCreateFlags = ^VkImageViewCreateFlags; - PPVkImageViewCreateFlags = ^PVkImageViewCreateFlags; + TVkPhysicalDeviceType = ( + 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_MAX_ENUM = $7FFFFFFF + ); + PVkPhysicalDeviceType = ^TVkPhysicalDeviceType; + PPVkPhysicalDeviceType = ^PVkPhysicalDeviceType; - _VkImageView = record end; - VkImageView = {$IFDEF VK_CPU64}^_VkImageView{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkImageView = ^VkImageView; - PPVkImageView = ^PVkImageView; + TVkQueueFlagBit = ( + VK_QUEUE_GRAPHICS_BIT = 0, + VK_QUEUE_COMPUTE_BIT = 1, + VK_QUEUE_TRANSFER_BIT = 2, + VK_QUEUE_SPARSE_BINDING_BIT = 3, + VK_QUEUE_MAX_BIT = 31 + ); + TVkQueueFlagBits = set of TVkQueueFlagBit; + + TVkMemoryPropertyFlagBit = ( + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 1, + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 2, + VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 3, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 4, + VK_MEMORY_PROPERTY_MAX_BIT = 31 + ); + TVkMemoryPropertyFlagBits = set of TVkMemoryPropertyFlagBit; - VkShaderModuleCreateFlags = VkFlags; - PVkShaderModuleCreateFlags = ^VkShaderModuleCreateFlags; - PPVkShaderModuleCreateFlags = ^PVkShaderModuleCreateFlags; + TVkMemoryHeapFlagBit = ( + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0, + VK_MEMORY_HEAP_DEVICE_LOCAL_BITMAX_BIT = 31 + ); + TVkMemoryHeapFlagBits = set of TVkMemoryHeapFlagBit; + + TVkPipelineStageFlagBit = ( + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0, + VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 1, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 2, + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 3, + VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 4, + VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 5, + VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 6, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 7, + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 8, + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 9, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 10, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 11, + VK_PIPELINE_STAGE_TRANSFER_BIT = 12, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 13, + VK_PIPELINE_STAGE_HOST_BIT = 14, + VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 15, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 16, + VK_PIPELINE_STAGE_MAX_BIT = 31 + ); + TVkPipelineStageFlagBits = set of TVkPipelineStageFlagBit; + + TVkImageAspectFlagBit = ( + VK_IMAGE_ASPECT_COLOR_BIT = 0, + VK_IMAGE_ASPECT_DEPTH_BIT = 1, + VK_IMAGE_ASPECT_STENCIL_BIT = 2, + VK_IMAGE_ASPECT_METADATA_BIT = 3, + VK_IMAGE_ASPECT_MAX_BIT = 31 + ); + TVkImageAspectFlagBits = set of TVkImageAspectFlagBit; - _VkShaderModule = record end; - VkShaderModule = {$IFDEF VK_CPU64}^_VkShaderModule{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkShaderModule = ^VkShaderModule; - PPVkShaderModule = ^PVkShaderModule; + TVkSparseImageFormatFlagBit = ( + VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0, + VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 1, + VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 2, + VK_SPARSE_IMAGE_FORMAT_MAX_BIT = 31 + ); + TVkSparseImageFormatFlagBits = set of TVkSparseImageFormatFlagBit; - VkPipelineCacheCreateFlags = VkFlags; - PVkPipelineCacheCreateFlags = ^VkPipelineCacheCreateFlags; - PPVkPipelineCacheCreateFlags = ^PVkPipelineCacheCreateFlags; + TVkSparseMemoryBindFlagBit = ( + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0, + VK_SPARSE_MEMORY_BIND_METADATA_BITMAX_BIT = 31 + ); + TVkSparseMemoryBindFlagBits = set of TVkSparseMemoryBindFlagBit; - _VkPipelineCache = record end; - VkPipelineCache = {$IFDEF VK_CPU64}^_VkPipelineCache{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkPipelineCache = ^VkPipelineCache; - PPVkPipelineCache = ^PVkPipelineCache; - - VkPipelineCreateFlags = VkFlags; - PVkPipelineCreateFlags = ^VkPipelineCreateFlags; - PPVkPipelineCreateFlags = ^PVkPipelineCreateFlags; - - VkPipelineShaderStageCreateFlags = VkFlags; - PVkPipelineShaderStageCreateFlags = ^VkPipelineShaderStageCreateFlags; - PPVkPipelineShaderStageCreateFlags = ^PVkPipelineShaderStageCreateFlags; - - VkPipelineVertexInputStateCreateFlags = VkFlags; - PVkPipelineVertexInputStateCreateFlags = ^VkPipelineVertexInputStateCreateFlags; - PPVkPipelineVertexInputStateCreateFlags = ^PVkPipelineVertexInputStateCreateFlags; + TVkFenceCreateFlagBit = ( + VK_FENCE_CREATE_SIGNALED_BIT = 0, + VK_FENCE_CREATE_SIGNALED_BITMAX_BIT = 31 + ); + TVkFenceCreateFlagBits = set of TVkFenceCreateFlagBit; - VkPipelineInputAssemblyStateCreateFlags = VkFlags; - PVkPipelineInputAssemblyStateCreateFlags = ^VkPipelineInputAssemblyStateCreateFlags; - PPVkPipelineInputAssemblyStateCreateFlags = ^PVkPipelineInputAssemblyStateCreateFlags; + TVkQueryType = ( + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_MAX_ENUM = $7FFFFFFF + ); + PVkQueryType = ^TVkQueryType; + PPVkQueryType = ^PVkQueryType; - VkPipelineTessellationStateCreateFlags = VkFlags; - PVkPipelineTessellationStateCreateFlags = ^VkPipelineTessellationStateCreateFlags; - PPVkPipelineTessellationStateCreateFlags = ^PVkPipelineTessellationStateCreateFlags; + TVkQueryPipelineStatisticFlagBit = ( + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0, + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 1, + VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 2, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 3, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 4, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 5, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 6, + VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 7, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 8, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 9, + VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 10, + VK_QUERY_PIPELINE_STATISTIC_MAX_BIT = 31 + ); + TVkQueryPipelineStatisticFlagBits = set of TVkQueryPipelineStatisticFlagBit; + + TVkQueryResultFlagBit = ( + VK_QUERY_RESULT_64_BIT = 0, + VK_QUERY_RESULT_WAIT_BIT = 1, + VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 2, + VK_QUERY_RESULT_PARTIAL_BIT = 3, + VK_QUERY_RESULT_MAX_BIT = 31 + ); + TVkQueryResultFlagBits = set of TVkQueryResultFlagBit; - VkPipelineViewportStateCreateFlags = VkFlags; - PVkPipelineViewportStateCreateFlags = ^VkPipelineViewportStateCreateFlags; - PPVkPipelineViewportStateCreateFlags = ^PVkPipelineViewportStateCreateFlags; + TVkBufferCreateFlagBit = ( + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 1, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 2, + VK_BUFFER_CREATE_SPARSE_MAX_BIT = 31 + ); + TVkBufferCreateFlagBits = set of TVkBufferCreateFlagBit; + + TVkBufferUsageFlagBit = ( + VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0, + VK_BUFFER_USAGE_TRANSFER_DST_BIT = 1, + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 2, + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 3, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 4, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 5, + VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 6, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 7, + VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 8, + VK_BUFFER_USAGE_MAX_BIT = 31 + ); + TVkBufferUsageFlagBits = set of TVkBufferUsageFlagBit; - VkPipelineRasterizationStateCreateFlags = VkFlags; - PVkPipelineRasterizationStateCreateFlags = ^VkPipelineRasterizationStateCreateFlags; - PPVkPipelineRasterizationStateCreateFlags = ^PVkPipelineRasterizationStateCreateFlags; + TVkSharingMode = ( + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_MAX_ENUM = $7FFFFFFF + ); + PVkSharingMode = ^TVkSharingMode; + PPVkSharingMode = ^PVkSharingMode; - VkCullModeFlags = VkFlags; - PVkCullModeFlags = ^VkCullModeFlags; - PPVkCullModeFlags = ^PVkCullModeFlags; + TVkImageLayout = ( + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_MAX_ENUM = $7FFFFFFF + ); + PVkImageLayout = ^TVkImageLayout; + PPVkImageLayout = ^PVkImageLayout; - VkPipelineMultisampleStateCreateFlags = VkFlags; - PVkPipelineMultisampleStateCreateFlags = ^VkPipelineMultisampleStateCreateFlags; - PPVkPipelineMultisampleStateCreateFlags = ^PVkPipelineMultisampleStateCreateFlags; + TVkImageViewType = ( + 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_MAX_ENUM = $7FFFFFFF + ); + PVkImageViewType = ^TVkImageViewType; + PPVkImageViewType = ^PVkImageViewType; - VkSampleMask = VkUint32; - PVkSampleMask = ^VkSampleMask; - PPVkSampleMask = ^PVkSampleMask; + TVkComponentSwizzle = ( + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_MAX_ENUM = $7FFFFFFF + ); + PVkComponentSwizzle = ^TVkComponentSwizzle; + PPVkComponentSwizzle = ^PVkComponentSwizzle; - VkPipelineDepthStencilStateCreateFlags = VkFlags; - PVkPipelineDepthStencilStateCreateFlags = ^VkPipelineDepthStencilStateCreateFlags; - PPVkPipelineDepthStencilStateCreateFlags = ^PVkPipelineDepthStencilStateCreateFlags; + TVkPipelineCreateFlagBit = ( + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 1, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 2, + VK_PIPELINE_CREATE_MAX_BIT = 31 + ); + TVkPipelineCreateFlagBits = set of TVkPipelineCreateFlagBit; + + TVkShaderStageFlagBit = ( + VK_SHADER_STAGE_VERTEX_BIT = 0, + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 1, + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 2, + VK_SHADER_STAGE_GEOMETRY_BIT = 3, + VK_SHADER_STAGE_FRAGMENT_BIT = 4, + VK_SHADER_STAGE_COMPUTE_BIT = 5, + VK_SHADER_STAGE_MAX_BIT = 31 + ); + TVkShaderStageFlagBits = set of TVkShaderStageFlagBit; - VkPipelineColorBlendStateCreateFlags = VkFlags; - PVkPipelineColorBlendStateCreateFlags = ^VkPipelineColorBlendStateCreateFlags; - PPVkPipelineColorBlendStateCreateFlags = ^PVkPipelineColorBlendStateCreateFlags; + TVkVertexInputRate = ( + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_MAX_ENUM = $7FFFFFFF + ); + PVkVertexInputRate = ^TVkVertexInputRate; + PPVkVertexInputRate = ^PVkVertexInputRate; - VkColorComponentFlags = VkFlags; - PVkColorComponentFlags = ^VkColorComponentFlags; - PPVkColorComponentFlags = ^PVkColorComponentFlags; + TVkPrimitiveTopology = ( + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = $7FFFFFFF + ); + PVkPrimitiveTopology = ^TVkPrimitiveTopology; + PPVkPrimitiveTopology = ^PVkPrimitiveTopology; - VkPipelineDynamicStateCreateFlags = VkFlags; - PVkPipelineDynamicStateCreateFlags = ^VkPipelineDynamicStateCreateFlags; - PPVkPipelineDynamicStateCreateFlags = ^PVkPipelineDynamicStateCreateFlags; + TVkPolygonMode = ( + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_MAX_ENUM = $7FFFFFFF + ); + PVkPolygonMode = ^TVkPolygonMode; + PPVkPolygonMode = ^PVkPolygonMode; - _VkPipelineLayout = record end; - VkPipelineLayout = {$IFDEF VK_CPU64}^_VkPipelineLayout{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkPipelineLayout = ^VkPipelineLayout; - PPVkPipelineLayout = ^PVkPipelineLayout; + TVkCullModeFlagBit = ( + VK_CULL_MODE_FRONT_BIT = 0, + VK_CULL_MODE_BACK_BIT = 1, + VK_CULL_MODE_MAX_BIT = 31 + ); + TVkCullModeFlagBits = set of TVkCullModeFlagBit; - _VkRenderPass = record end; - VkRenderPass = {$IFDEF VK_CPU64}^_VkRenderPass{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkRenderPass = ^VkRenderPass; - PPVkRenderPass = ^PVkRenderPass; + TVkFrontFace = ( + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_MAX_ENUM = $7FFFFFFF + ); + PVkFrontFace = ^TVkFrontFace; + PPVkFrontFace = ^PVkFrontFace; - _VkPipeline = record end; - VkPipeline = {$IFDEF VK_CPU64}^_VkPipeline{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkPipeline = ^VkPipeline; - PPVkPipeline = ^PVkPipeline; + TVkCompareOp = ( + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_MAX_ENUM = $7FFFFFFF + ); + PVkCompareOp = ^TVkCompareOp; + PPVkCompareOp = ^PVkCompareOp; - VkPipelineLayoutCreateFlags = VkFlags; - PVkPipelineLayoutCreateFlags = ^VkPipelineLayoutCreateFlags; - PPVkPipelineLayoutCreateFlags = ^PVkPipelineLayoutCreateFlags; + TVkStencilOp = ( + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_MAX_ENUM = $7FFFFFFF + ); + PVkStencilOp = ^TVkStencilOp; + PPVkStencilOp = ^PVkStencilOp; - _VkDescriptorSetLayout = record end; - VkDescriptorSetLayout = {$IFDEF VK_CPU64}^_VkDescriptorSetLayout{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkDescriptorSetLayout = ^VkDescriptorSetLayout; - PPVkDescriptorSetLayout = ^PVkDescriptorSetLayout; + TVkLogicOp = ( + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_MAX_ENUM = $7FFFFFFF + ); + PVkLogicOp = ^TVkLogicOp; + PPVkLogicOp = ^PVkLogicOp; - VkShaderStageFlags = VkFlags; - PVkShaderStageFlags = ^VkShaderStageFlags; - PPVkShaderStageFlags = ^PVkShaderStageFlags; + TVkBlendFactor = ( + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_MAX_ENUM = $7FFFFFFF + ); + PVkBlendFactor = ^TVkBlendFactor; + PPVkBlendFactor = ^PVkBlendFactor; - VkSamplerCreateFlags = VkFlags; - PVkSamplerCreateFlags = ^VkSamplerCreateFlags; - PPVkSamplerCreateFlags = ^PVkSamplerCreateFlags; + TVkBlendOp = ( + 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_MAX_ENUM = $7FFFFFFF + ); + PVkBlendOp = ^TVkBlendOp; + PPVkBlendOp = ^PVkBlendOp; - _VkSampler = record end; - VkSampler = {$IFDEF VK_CPU64}^_VkSampler{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkSampler = ^VkSampler; - PPVkSampler = ^PVkSampler; + TVkColorComponentFlagBit = ( + VK_COLOR_COMPONENT_R_BIT = 0, + VK_COLOR_COMPONENT_G_BIT = 1, + VK_COLOR_COMPONENT_B_BIT = 2, + VK_COLOR_COMPONENT_A_BIT = 3, + VK_COLOR_COMPONENT_MAX_BIT = 31 + ); + TVkColorComponentFlagBits = set of TVkColorComponentFlagBit; - VkDescriptorSetLayoutCreateFlags = VkFlags; - PVkDescriptorSetLayoutCreateFlags = ^VkDescriptorSetLayoutCreateFlags; - PPVkDescriptorSetLayoutCreateFlags = ^PVkDescriptorSetLayoutCreateFlags; + TVkDynamicState = ( + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_MAX_ENUM = $7FFFFFFF + ); + PVkDynamicState = ^TVkDynamicState; + PPVkDynamicState = ^PVkDynamicState; - VkDescriptorPoolCreateFlags = VkFlags; - PVkDescriptorPoolCreateFlags = ^VkDescriptorPoolCreateFlags; - PPVkDescriptorPoolCreateFlags = ^PVkDescriptorPoolCreateFlags; + TVkFilter = ( + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_MAX_ENUM = $7FFFFFFF + ); + PVkFilter = ^TVkFilter; + PPVkFilter = ^PVkFilter; - _VkDescriptorPool = record end; - VkDescriptorPool = {$IFDEF VK_CPU64}^_VkDescriptorPool{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkDescriptorPool = ^VkDescriptorPool; - PPVkDescriptorPool = ^PVkDescriptorPool; + TVkSamplerMipmapMode = ( + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = $7FFFFFFF + ); + PVkSamplerMipmapMode = ^TVkSamplerMipmapMode; + PPVkSamplerMipmapMode = ^PVkSamplerMipmapMode; - VkDescriptorPoolResetFlags = VkFlags; - PVkDescriptorPoolResetFlags = ^VkDescriptorPoolResetFlags; - PPVkDescriptorPoolResetFlags = ^PVkDescriptorPoolResetFlags; + TVkSamplerAddressMode = ( + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = $7FFFFFFF + ); + PVkSamplerAddressMode = ^TVkSamplerAddressMode; + PPVkSamplerAddressMode = ^PVkSamplerAddressMode; - _VkDescriptorSet = record end; - VkDescriptorSet = {$IFDEF VK_CPU64}^_VkDescriptorSet{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkDescriptorSet = ^VkDescriptorSet; - PPVkDescriptorSet = ^PVkDescriptorSet; + TVkBorderColor = ( + 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_MAX_ENUM = $7FFFFFFF + ); + PVkBorderColor = ^TVkBorderColor; + PPVkBorderColor = ^PVkBorderColor; - VkFramebufferCreateFlags = VkFlags; - PVkFramebufferCreateFlags = ^VkFramebufferCreateFlags; - PPVkFramebufferCreateFlags = ^PVkFramebufferCreateFlags; + TVkDescriptorType = ( + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_MAX_ENUM = $7FFFFFFF + ); + PVkDescriptorType = ^TVkDescriptorType; + PPVkDescriptorType = ^PVkDescriptorType; - _VkFramebuffer = record end; - VkFramebuffer = {$IFDEF VK_CPU64}^_VkFramebuffer{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkFramebuffer = ^VkFramebuffer; - PPVkFramebuffer = ^PVkFramebuffer; + TVkDescriptorPoolCreateFlagBit = ( + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0, + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BITMAX_BIT = 31 + ); + TVkDescriptorPoolCreateFlagBits = set of TVkDescriptorPoolCreateFlagBit; - VkRenderPassCreateFlags = VkFlags; - PVkRenderPassCreateFlags = ^VkRenderPassCreateFlags; - PPVkRenderPassCreateFlags = ^PVkRenderPassCreateFlags; + TVkAttachmentDescriptionFlagBit = ( + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0, + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BITMAX_BIT = 31 + ); + TVkAttachmentDescriptionFlagBits = set of TVkAttachmentDescriptionFlagBit; - VkAttachmentDescriptionFlags = VkFlags; - PVkAttachmentDescriptionFlags = ^VkAttachmentDescriptionFlags; - PPVkAttachmentDescriptionFlags = ^PVkAttachmentDescriptionFlags; + TVkAttachmentLoadOp = ( + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = $7FFFFFFF + ); + PVkAttachmentLoadOp = ^TVkAttachmentLoadOp; + PPVkAttachmentLoadOp = ^PVkAttachmentLoadOp; - VkSubpassDescriptionFlags = VkFlags; - PVkSubpassDescriptionFlags = ^VkSubpassDescriptionFlags; - PPVkSubpassDescriptionFlags = ^PVkSubpassDescriptionFlags; + TVkAttachmentStoreOp = ( + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_MAX_ENUM = $7FFFFFFF + ); + PVkAttachmentStoreOp = ^TVkAttachmentStoreOp; + PPVkAttachmentStoreOp = ^PVkAttachmentStoreOp; - VkAccessFlags = VkFlags; - PVkAccessFlags = ^VkAccessFlags; - PPVkAccessFlags = ^PVkAccessFlags; + TVkPipelineBindPoint = ( + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_MAX_ENUM = $7FFFFFFF + ); + PVkPipelineBindPoint = ^TVkPipelineBindPoint; + PPVkPipelineBindPoint = ^PVkPipelineBindPoint; - VkDependencyFlags = VkFlags; - PVkDependencyFlags = ^VkDependencyFlags; - PPVkDependencyFlags = ^PVkDependencyFlags; + TVkAccessFlagBit = ( + VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0, + VK_ACCESS_INDEX_READ_BIT = 1, + VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 2, + VK_ACCESS_UNIFORM_READ_BIT = 3, + VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 4, + VK_ACCESS_SHADER_READ_BIT = 5, + VK_ACCESS_SHADER_WRITE_BIT = 6, + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 7, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 8, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 9, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 10, + VK_ACCESS_TRANSFER_READ_BIT = 11, + VK_ACCESS_TRANSFER_WRITE_BIT = 12, + VK_ACCESS_HOST_READ_BIT = 13, + VK_ACCESS_HOST_WRITE_BIT = 14, + VK_ACCESS_MEMORY_READ_BIT = 15, + VK_ACCESS_MEMORY_WRITE_BIT = 16, + VK_ACCESS_MAX_BIT = 31 + ); + TVkAccessFlagBits = set of TVkAccessFlagBit; - VkCommandPoolCreateFlags = VkFlags; - PVkCommandPoolCreateFlags = ^VkCommandPoolCreateFlags; - PPVkCommandPoolCreateFlags = ^PVkCommandPoolCreateFlags; + TVkDependencyFlagBit = ( + VK_DEPENDENCY_BY_REGION_BIT = 0, + VK_DEPENDENCY_BY_REGION_BITMAX_BIT = 31 + ); + TVkDependencyFlagBits = set of TVkDependencyFlagBit; - VkCommandPoolResetFlags = VkFlags; - PVkCommandPoolResetFlags = ^VkCommandPoolResetFlags; - PPVkCommandPoolResetFlags = ^PVkCommandPoolResetFlags; + TVkCommandPoolCreateFlagBit = ( + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 1, + VK_COMMAND_POOL_CREATE_MAX_BIT = 31 + ); + TVkCommandPoolCreateFlagBits = set of TVkCommandPoolCreateFlagBit; - VkCommandBufferUsageFlags = VkFlags; - PVkCommandBufferUsageFlags = ^VkCommandBufferUsageFlags; - PPVkCommandBufferUsageFlags = ^PVkCommandBufferUsageFlags; + TVkCommandPoolResetFlagBit = ( + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0, + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BITMAX_BIT = 31 + ); + TVkCommandPoolResetFlagBits = set of TVkCommandPoolResetFlagBit; - VkQueryControlFlags = VkFlags; - PVkQueryControlFlags = ^VkQueryControlFlags; - PPVkQueryControlFlags = ^PVkQueryControlFlags; + TVkCommandBufferLevel = ( + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = $7FFFFFFF + ); + PVkCommandBufferLevel = ^TVkCommandBufferLevel; + PPVkCommandBufferLevel = ^PVkCommandBufferLevel; - VkCommandBufferResetFlags = VkFlags; - PVkCommandBufferResetFlags = ^VkCommandBufferResetFlags; - PPVkCommandBufferResetFlags = ^PVkCommandBufferResetFlags; + TVkCommandBufferUsageFlagBit = ( + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0, + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 1, + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 2, + VK_COMMAND_BUFFER_USAGE_MAX_BIT = 31 + ); + TVkCommandBufferUsageFlagBits = set of TVkCommandBufferUsageFlagBit; - VkStencilFaceFlags = VkFlags; - PVkStencilFaceFlags = ^VkStencilFaceFlags; - PPVkStencilFaceFlags = ^PVkStencilFaceFlags; + TVkQueryControlFlagBit = ( + VK_QUERY_CONTROL_PRECISE_BIT = 0, + VK_QUERY_CONTROL_PRECISE_BITMAX_BIT = 31 + ); + TVkQueryControlFlagBits = set of TVkQueryControlFlagBit; -{ ========================================== VK_KHR_surface ========================================== } - _VkSurfaceKHR = record end; - VkSurfaceKHR = {$IFDEF VK_CPU64}^_VkSurfaceKHR{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkSurfaceKHR = ^VkSurfaceKHR; - PPVkSurfaceKHR = ^PVkSurfaceKHR; + TVkCommandBufferResetFlagBit = ( + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0, + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BITMAX_BIT = 31 + ); + TVkCommandBufferResetFlagBits = set of TVkCommandBufferResetFlagBit; - VkSurfaceTransformFlagsKHR = VkFlags; - PVkSurfaceTransformFlagsKHR = ^VkSurfaceTransformFlagsKHR; - PPVkSurfaceTransformFlagsKHR = ^PVkSurfaceTransformFlagsKHR; + TVkStencilFaceFlagBit = ( + VK_STENCIL_FACE_FRONT_BIT = 0, + VK_STENCIL_FACE_BACK_BIT = 1, + VK_STENCIL_FMAX_BIT = 31 + ); + TVkStencilFaceFlagBits = set of TVkStencilFaceFlagBit; - VkCompositeAlphaFlagsKHR = VkFlags; - PVkCompositeAlphaFlagsKHR = ^VkCompositeAlphaFlagsKHR; - PPVkCompositeAlphaFlagsKHR = ^PVkCompositeAlphaFlagsKHR; + TVkIndexType = ( + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_MAX_ENUM = $7FFFFFFF + ); + PVkIndexType = ^TVkIndexType; + PPVkIndexType = ^PVkIndexType; -{ ========================================= VK_KHR_swapchain ========================================= } - VkSwapchainCreateFlagsKHR = VkFlags; - PVkSwapchainCreateFlagsKHR = ^VkSwapchainCreateFlagsKHR; - PPVkSwapchainCreateFlagsKHR = ^PVkSwapchainCreateFlagsKHR; + TVkSubpassContents = ( + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_MAX_ENUM = $7FFFFFFF + ); + PVkSubpassContents = ^TVkSubpassContents; + PPVkSubpassContents = ^PVkSubpassContents; - _VkSwapchainKHR = record end; - VkSwapchainKHR = {$IFDEF VK_CPU64}^_VkSwapchainKHR{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkSwapchainKHR = ^VkSwapchainKHR; - PPVkSwapchainKHR = ^PVkSwapchainKHR; +{ ========================================== VK_KHR_surface ========================================== } + TVkSurfaceTransformFlagBitKHR = ( + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0, + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 1, + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 2, + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 3, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 4, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 5, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 6, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 7, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 8, + VK_SURFACE_TRANSFORM_MAX_BIT = 31 + ); + TVkSurfaceTransformFlagBitsKHR = set of TVkSurfaceTransformFlagBitKHR; + + TVkCompositeAlphaFlagBitKHR = ( + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0, + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 1, + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 2, + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 3, + VK_COMPOSITE_ALPHA_MAX_BIT = 31 + ); + TVkCompositeAlphaFlagBitsKHR = set of TVkCompositeAlphaFlagBitKHR; + + TVkColorSpaceKHR = ( + VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLORSPACE_MAX_ENUM = $7FFFFFFF + ); + PVkColorSpaceKHR = ^TVkColorSpaceKHR; + PPVkColorSpaceKHR = ^PVkColorSpaceKHR; + + TVkPresentModeKHR = ( + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_MAX_ENUM = $7FFFFFFF + ); + PVkPresentModeKHR = ^TVkPresentModeKHR; + PPVkPresentModeKHR = ^PVkPresentModeKHR; { ========================================== VK_KHR_display ========================================== } - _VkDisplayKHR = record end; - VkDisplayKHR = {$IFDEF VK_CPU64}^_VkDisplayKHR{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkDisplayKHR = ^VkDisplayKHR; - PPVkDisplayKHR = ^PVkDisplayKHR; + TVkDisplayPlaneAlphaFlagBitKHR = ( + VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0, + VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 1, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 2, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 3, + VK_DISPLAY_PLANE_ALPHA_MAX_BIT = 31 + ); + TVkDisplayPlaneAlphaFlagBitsKHR = set of TVkDisplayPlaneAlphaFlagBitKHR; - _VkDisplayModeKHR = record end; - VkDisplayModeKHR = {$IFDEF VK_CPU64}^_VkDisplayModeKHR{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkDisplayModeKHR = ^VkDisplayModeKHR; - PPVkDisplayModeKHR = ^PVkDisplayModeKHR; +{ ======================================= VK_EXT_debug_report ======================================== } + TVkDebugReportObjectTypeEXT = ( + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, + VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, + VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, + VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, + VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, + VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, + VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, + VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, + VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, + VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, + VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, + VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, + VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, + VK_DEBUG_REPORT_OBJECT_TYPE__MAX_ENUM = $7FFFFFFF + ); + PVkDebugReportObjectTypeEXT = ^TVkDebugReportObjectTypeEXT; + PPVkDebugReportObjectTypeEXT = ^PVkDebugReportObjectTypeEXT; - VkDisplayModeCreateFlagsKHR = VkFlags; - PVkDisplayModeCreateFlagsKHR = ^VkDisplayModeCreateFlagsKHR; - PPVkDisplayModeCreateFlagsKHR = ^PVkDisplayModeCreateFlagsKHR; + TVkDebugReportErrorEXT = ( + VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, + VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, + VK_DEBUG_REPORT_ERROR__MAX_ENUM = $7FFFFFFF + ); + PVkDebugReportErrorEXT = ^TVkDebugReportErrorEXT; + PPVkDebugReportErrorEXT = ^PVkDebugReportErrorEXT; - VkDisplayPlaneAlphaFlagsKHR = VkFlags; - PVkDisplayPlaneAlphaFlagsKHR = ^VkDisplayPlaneAlphaFlagsKHR; - PPVkDisplayPlaneAlphaFlagsKHR = ^PVkDisplayPlaneAlphaFlagsKHR; + TVkDebugReportFlagBitEXT = ( + VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0, + VK_DEBUG_REPORT_WARNING_BIT_EXT = 1, + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 2, + VK_DEBUG_REPORT_ERROR_BIT_EXT = 3, + VK_DEBUG_REPORT_DEBUG_BIT_EXT = 4, + VK_DEBUG_REPORT_MAX_BIT = 31 + ); + TVkDebugReportFlagBitsEXT = set of TVkDebugReportFlagBitEXT; - VkDisplaySurfaceCreateFlagsKHR = VkFlags; - PVkDisplaySurfaceCreateFlagsKHR = ^VkDisplaySurfaceCreateFlagsKHR; - PPVkDisplaySurfaceCreateFlagsKHR = ^PVkDisplaySurfaceCreateFlagsKHR; +type { simple types } -{ ======================================= VK_KHR_xlib_surface ======================================== } -{$IFDEF VK_USE_PLATFORM_XLIB_KHR} - VkXlibSurfaceCreateFlagsKHR = VkFlags; - PVkXlibSurfaceCreateFlagsKHR = ^VkXlibSurfaceCreateFlagsKHR; - PPVkXlibSurfaceCreateFlagsKHR = ^PVkXlibSurfaceCreateFlagsKHR; -{$ENDIF} +{ ========================================== VK_VERSION_1_0 ========================================== } + VkFlags = VkUint32; + PVkFlags = ^VkFlags; + PPVkFlags = ^PVkFlags; -{ ======================================== VK_KHR_xcb_surface ======================================== } -{$IFDEF VK_USE_PLATFORM_XCB_KHR} - VkXcbSurfaceCreateFlagsKHR = VkFlags; - PVkXcbSurfaceCreateFlagsKHR = ^VkXcbSurfaceCreateFlagsKHR; - PPVkXcbSurfaceCreateFlagsKHR = ^PVkXcbSurfaceCreateFlagsKHR; -{$ENDIF} + VkInstanceCreateFlags = VkFlags; + PVkInstanceCreateFlags = ^VkInstanceCreateFlags; + PPVkInstanceCreateFlags = ^PVkInstanceCreateFlags; -{ ====================================== VK_KHR_wayland_surface ====================================== } -{$IFDEF VK_USE_PLATFORM_WAYLAND_KHR} - VkWaylandSurfaceCreateFlagsKHR = VkFlags; - PVkWaylandSurfaceCreateFlagsKHR = ^VkWaylandSurfaceCreateFlagsKHR; - PPVkWaylandSurfaceCreateFlagsKHR = ^PVkWaylandSurfaceCreateFlagsKHR; -{$ENDIF} + _VkInstance = record end; + VkInstance = ^_VkInstance; + PVkInstance = ^VkInstance; + PPVkInstance = ^PVkInstance; -{ ======================================== VK_KHR_mir_surface ======================================== } -{$IFDEF VK_USE_PLATFORM_MIR_KHR} - VkMirSurfaceCreateFlagsKHR = VkFlags; - PVkMirSurfaceCreateFlagsKHR = ^VkMirSurfaceCreateFlagsKHR; - PPVkMirSurfaceCreateFlagsKHR = ^PVkMirSurfaceCreateFlagsKHR; -{$ENDIF} + _VkPhysicalDevice = record end; + VkPhysicalDevice = ^_VkPhysicalDevice; + PVkPhysicalDevice = ^VkPhysicalDevice; + PPVkPhysicalDevice = ^PVkPhysicalDevice; -{ ====================================== VK_KHR_android_surface ====================================== } -{$IFDEF VK_USE_PLATFORM_ANDROID_KHR} - VkAndroidSurfaceCreateFlagsKHR = VkFlags; - PVkAndroidSurfaceCreateFlagsKHR = ^VkAndroidSurfaceCreateFlagsKHR; - PPVkAndroidSurfaceCreateFlagsKHR = ^PVkAndroidSurfaceCreateFlagsKHR; -{$ENDIF} + VkBool32 = VkUint32; + PVkBool32 = ^VkBool32; + PPVkBool32 = ^PVkBool32; -{ ======================================= VK_KHR_win32_surface ======================================= } -{$IFDEF VK_USE_PLATFORM_WIN32_KHR} - VkWin32SurfaceCreateFlagsKHR = VkFlags; - PVkWin32SurfaceCreateFlagsKHR = ^VkWin32SurfaceCreateFlagsKHR; - PPVkWin32SurfaceCreateFlagsKHR = ^PVkWin32SurfaceCreateFlagsKHR; -{$ENDIF} + VkFormatFeatureFlags = TVkFormatFeatureFlagBits; + PVkFormatFeatureFlags = ^VkFormatFeatureFlags; + PPVkFormatFeatureFlags = ^PVkFormatFeatureFlags; -{ ======================================= VK_EXT_debug_report ======================================== } - VkDebugReportFlagsEXT = VkFlags; - PVkDebugReportFlagsEXT = ^VkDebugReportFlagsEXT; - PPVkDebugReportFlagsEXT = ^PVkDebugReportFlagsEXT; + VkImageUsageFlags = TVkImageUsageFlagBits; + PVkImageUsageFlags = ^VkImageUsageFlags; + PPVkImageUsageFlags = ^PVkImageUsageFlags; - _VkDebugReportCallbackEXT = record end; - VkDebugReportCallbackEXT = {$IFDEF VK_CPU64}^_VkDebugReportCallbackEXT{$ELSE}VkNonDispatchableHandle{$ENDIF}; - PVkDebugReportCallbackEXT = ^VkDebugReportCallbackEXT; - PPVkDebugReportCallbackEXT = ^PVkDebugReportCallbackEXT; + VkImageCreateFlags = TVkImageCreateFlagBits; + PVkImageCreateFlags = ^VkImageCreateFlags; + PPVkImageCreateFlags = ^PVkImageCreateFlags; -type { enumerations } + VkSampleCountFlags = TVkSampleCountFlagBits; + PVkSampleCountFlags = ^VkSampleCountFlags; + PPVkSampleCountFlags = ^PVkSampleCountFlags; -{ ========================================== VK_VERSION_1_0 ========================================== } - TVkPipelineCacheHeaderVersion = ( - VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, - VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = $7FFFFFFF - ); - PVkPipelineCacheHeaderVersion = ^TVkPipelineCacheHeaderVersion; - PPVkPipelineCacheHeaderVersion = ^PVkPipelineCacheHeaderVersion; + VkDeviceSize = VkUint64; + PVkDeviceSize = ^VkDeviceSize; + PPVkDeviceSize = ^PVkDeviceSize; - TVkResult = ( - VK_SUCCESS = 0, - VK_NOT_READY = 1, - VK_TIMEOUT = 2, - VK_EVENT_SET = 3, - VK_EVENT_RESET = 4, - VK_INCOMPLETE = 5, - VK_ERROR_OUT_OF_HOST_MEMORY = -1, - VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, - VK_ERROR_INITIALIZATION_FAILED = -3, - VK_ERROR_DEVICE_LOST = -4, - VK_ERROR_MEMORY_MAP_FAILED = -5, - VK_ERROR_LAYER_NOT_PRESENT = -6, - VK_ERROR_EXTENSION_NOT_PRESENT = -7, - VK_ERROR_FEATURE_NOT_PRESENT = -8, - VK_ERROR_INCOMPATIBLE_DRIVER = -9, - VK_ERROR_TOO_MANY_OBJECTS = -10, - VK_ERROR_FORMAT_NOT_SUPPORTED = -11, - VK_ERROR_SURFACE_LOST_KHR = -1000000000, - VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, - VK_SUBOPTIMAL_KHR = 1000001003, - VK_ERROR_OUT_OF_DATE_KHR = -1000001004, - VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, - VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, - VK_RESULT_MAX_ENUM = $7FFFFFFF - ); - PVkResult = ^TVkResult; - PPVkResult = ^PVkResult; + VkQueueFlags = TVkQueueFlagBits; + PVkQueueFlags = ^VkQueueFlags; + PPVkQueueFlags = ^PVkQueueFlags; - TVkStructureType = ( - VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, - VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, - VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, - VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, - VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, - VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, - VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, - VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, - VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, - VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, - VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, - VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, - VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, - VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, - VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, - VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, - VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, - VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, - VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, - VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, - VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, - VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000, - VK_STRUCTURE_TYPE_MAX_ENUM = $7FFFFFFF - ); - PVkStructureType = ^TVkStructureType; - PPVkStructureType = ^PVkStructureType; + VkMemoryPropertyFlags = TVkMemoryPropertyFlagBits; + PVkMemoryPropertyFlags = ^VkMemoryPropertyFlags; + PPVkMemoryPropertyFlags = ^PVkMemoryPropertyFlags; - TVkSystemAllocationScope = ( - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, - VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, - VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, - VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = $7FFFFFFF - ); - PVkSystemAllocationScope = ^TVkSystemAllocationScope; - PPVkSystemAllocationScope = ^PVkSystemAllocationScope; + VkMemoryHeapFlags = TVkMemoryHeapFlagBits; + PVkMemoryHeapFlags = ^VkMemoryHeapFlags; + PPVkMemoryHeapFlags = ^PVkMemoryHeapFlags; - TVkInternalAllocationType = ( - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, - VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = $7FFFFFFF - ); - PVkInternalAllocationType = ^TVkInternalAllocationType; - PPVkInternalAllocationType = ^PVkInternalAllocationType; + _VkDevice = record end; + VkDevice = ^_VkDevice; + PVkDevice = ^VkDevice; + PPVkDevice = ^PVkDevice; - TVkFormat = ( - VK_FORMAT_UNDEFINED = 0, - VK_FORMAT_R4G4_UNORM_PACK8 = 1, - VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, - VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, - VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, - VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, - VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, - VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, - VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, - VK_FORMAT_R8_UNORM = 9, - VK_FORMAT_R8_SNORM = 10, - VK_FORMAT_R8_USCALED = 11, - VK_FORMAT_R8_SSCALED = 12, - VK_FORMAT_R8_UINT = 13, - VK_FORMAT_R8_SINT = 14, - VK_FORMAT_R8_SRGB = 15, - VK_FORMAT_R8G8_UNORM = 16, - VK_FORMAT_R8G8_SNORM = 17, - VK_FORMAT_R8G8_USCALED = 18, - VK_FORMAT_R8G8_SSCALED = 19, - VK_FORMAT_R8G8_UINT = 20, - VK_FORMAT_R8G8_SINT = 21, - VK_FORMAT_R8G8_SRGB = 22, - VK_FORMAT_R8G8B8_UNORM = 23, - VK_FORMAT_R8G8B8_SNORM = 24, - VK_FORMAT_R8G8B8_USCALED = 25, - VK_FORMAT_R8G8B8_SSCALED = 26, - VK_FORMAT_R8G8B8_UINT = 27, - VK_FORMAT_R8G8B8_SINT = 28, - VK_FORMAT_R8G8B8_SRGB = 29, - VK_FORMAT_B8G8R8_UNORM = 30, - VK_FORMAT_B8G8R8_SNORM = 31, - VK_FORMAT_B8G8R8_USCALED = 32, - VK_FORMAT_B8G8R8_SSCALED = 33, - VK_FORMAT_B8G8R8_UINT = 34, - VK_FORMAT_B8G8R8_SINT = 35, - VK_FORMAT_B8G8R8_SRGB = 36, - VK_FORMAT_R8G8B8A8_UNORM = 37, - VK_FORMAT_R8G8B8A8_SNORM = 38, - VK_FORMAT_R8G8B8A8_USCALED = 39, - VK_FORMAT_R8G8B8A8_SSCALED = 40, - VK_FORMAT_R8G8B8A8_UINT = 41, - VK_FORMAT_R8G8B8A8_SINT = 42, - VK_FORMAT_R8G8B8A8_SRGB = 43, - VK_FORMAT_B8G8R8A8_UNORM = 44, - VK_FORMAT_B8G8R8A8_SNORM = 45, - VK_FORMAT_B8G8R8A8_USCALED = 46, - VK_FORMAT_B8G8R8A8_SSCALED = 47, - VK_FORMAT_B8G8R8A8_UINT = 48, - VK_FORMAT_B8G8R8A8_SINT = 49, - VK_FORMAT_B8G8R8A8_SRGB = 50, - VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, - VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, - VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, - VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, - VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, - VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, - VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, - VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, - VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, - VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, - VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, - VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, - VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, - VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, - VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, - VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, - VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, - VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, - VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, - VK_FORMAT_R16_UNORM = 70, - VK_FORMAT_R16_SNORM = 71, - VK_FORMAT_R16_USCALED = 72, - VK_FORMAT_R16_SSCALED = 73, - VK_FORMAT_R16_UINT = 74, - VK_FORMAT_R16_SINT = 75, - VK_FORMAT_R16_SFLOAT = 76, - VK_FORMAT_R16G16_UNORM = 77, - VK_FORMAT_R16G16_SNORM = 78, - VK_FORMAT_R16G16_USCALED = 79, - VK_FORMAT_R16G16_SSCALED = 80, - VK_FORMAT_R16G16_UINT = 81, - VK_FORMAT_R16G16_SINT = 82, - VK_FORMAT_R16G16_SFLOAT = 83, - VK_FORMAT_R16G16B16_UNORM = 84, - VK_FORMAT_R16G16B16_SNORM = 85, - VK_FORMAT_R16G16B16_USCALED = 86, - VK_FORMAT_R16G16B16_SSCALED = 87, - VK_FORMAT_R16G16B16_UINT = 88, - VK_FORMAT_R16G16B16_SINT = 89, - VK_FORMAT_R16G16B16_SFLOAT = 90, - VK_FORMAT_R16G16B16A16_UNORM = 91, - VK_FORMAT_R16G16B16A16_SNORM = 92, - VK_FORMAT_R16G16B16A16_USCALED = 93, - VK_FORMAT_R16G16B16A16_SSCALED = 94, - VK_FORMAT_R16G16B16A16_UINT = 95, - VK_FORMAT_R16G16B16A16_SINT = 96, - VK_FORMAT_R16G16B16A16_SFLOAT = 97, - VK_FORMAT_R32_UINT = 98, - VK_FORMAT_R32_SINT = 99, - VK_FORMAT_R32_SFLOAT = 100, - VK_FORMAT_R32G32_UINT = 101, - VK_FORMAT_R32G32_SINT = 102, - VK_FORMAT_R32G32_SFLOAT = 103, - VK_FORMAT_R32G32B32_UINT = 104, - VK_FORMAT_R32G32B32_SINT = 105, - VK_FORMAT_R32G32B32_SFLOAT = 106, - VK_FORMAT_R32G32B32A32_UINT = 107, - VK_FORMAT_R32G32B32A32_SINT = 108, - VK_FORMAT_R32G32B32A32_SFLOAT = 109, - VK_FORMAT_R64_UINT = 110, - VK_FORMAT_R64_SINT = 111, - VK_FORMAT_R64_SFLOAT = 112, - VK_FORMAT_R64G64_UINT = 113, - VK_FORMAT_R64G64_SINT = 114, - VK_FORMAT_R64G64_SFLOAT = 115, - VK_FORMAT_R64G64B64_UINT = 116, - VK_FORMAT_R64G64B64_SINT = 117, - VK_FORMAT_R64G64B64_SFLOAT = 118, - VK_FORMAT_R64G64B64A64_UINT = 119, - VK_FORMAT_R64G64B64A64_SINT = 120, - VK_FORMAT_R64G64B64A64_SFLOAT = 121, - VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, - VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, - VK_FORMAT_D16_UNORM = 124, - VK_FORMAT_X8_D24_UNORM_PACK32 = 125, - VK_FORMAT_D32_SFLOAT = 126, - VK_FORMAT_S8_UINT = 127, - VK_FORMAT_D16_UNORM_S8_UINT = 128, - VK_FORMAT_D24_UNORM_S8_UINT = 129, - VK_FORMAT_D32_SFLOAT_S8_UINT = 130, - VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, - VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, - VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, - VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, - VK_FORMAT_BC2_UNORM_BLOCK = 135, - VK_FORMAT_BC2_SRGB_BLOCK = 136, - VK_FORMAT_BC3_UNORM_BLOCK = 137, - VK_FORMAT_BC3_SRGB_BLOCK = 138, - VK_FORMAT_BC4_UNORM_BLOCK = 139, - VK_FORMAT_BC4_SNORM_BLOCK = 140, - VK_FORMAT_BC5_UNORM_BLOCK = 141, - VK_FORMAT_BC5_SNORM_BLOCK = 142, - VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, - VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, - VK_FORMAT_BC7_UNORM_BLOCK = 145, - VK_FORMAT_BC7_SRGB_BLOCK = 146, - VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, - VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, - VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, - VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, - VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, - VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, - VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, - VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, - VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, - VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, - VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, - VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, - VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, - VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, - VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, - VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, - VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, - VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, - VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, - VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, - VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, - VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, - VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, - VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, - VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, - VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, - VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, - VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, - VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, - VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, - VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, - VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, - VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, - VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, - VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, - VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, - VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, - VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, - VK_FORMAT_MAX_ENUM = $7FFFFFFF - ); - PVkFormat = ^TVkFormat; - PPVkFormat = ^PVkFormat; + VkDeviceCreateFlags = VkFlags; + PVkDeviceCreateFlags = ^VkDeviceCreateFlags; + PPVkDeviceCreateFlags = ^PVkDeviceCreateFlags; - TVkImageType = ( - VK_IMAGE_TYPE_1D = 0, - VK_IMAGE_TYPE_2D = 1, - VK_IMAGE_TYPE_3D = 2, - VK_IMAGE_TYPE_MAX_ENUM = $7FFFFFFF - ); - PVkImageType = ^TVkImageType; - PPVkImageType = ^PVkImageType; + VkDeviceQueueCreateFlags = VkFlags; + PVkDeviceQueueCreateFlags = ^VkDeviceQueueCreateFlags; + PPVkDeviceQueueCreateFlags = ^PVkDeviceQueueCreateFlags; - TVkImageTiling = ( - VK_IMAGE_TILING_OPTIMAL = 0, - VK_IMAGE_TILING_LINEAR = 1, - VK_IMAGE_TILING_MAX_ENUM = $7FFFFFFF - ); - PVkImageTiling = ^TVkImageTiling; - PPVkImageTiling = ^PVkImageTiling; + _VkQueue = record end; + VkQueue = ^_VkQueue; + PVkQueue = ^VkQueue; + PPVkQueue = ^PVkQueue; - TVkPhysicalDeviceType = ( - 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_MAX_ENUM = $7FFFFFFF - ); - PVkPhysicalDeviceType = ^TVkPhysicalDeviceType; - PPVkPhysicalDeviceType = ^PVkPhysicalDeviceType; + _VkSemaphore = record end; + VkSemaphore = {$IFDEF VK_CPU64}^_VkSemaphore{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkSemaphore = ^VkSemaphore; + PPVkSemaphore = ^PVkSemaphore; + + VkPipelineStageFlags = TVkPipelineStageFlagBits; + PVkPipelineStageFlags = ^VkPipelineStageFlags; + PPVkPipelineStageFlags = ^PVkPipelineStageFlags; + + _VkCommandPool = record end; + VkCommandPool = {$IFDEF VK_CPU64}^_VkCommandPool{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkCommandPool = ^VkCommandPool; + PPVkCommandPool = ^PVkCommandPool; + + _VkCommandBuffer = record end; + VkCommandBuffer = ^_VkCommandBuffer; + PVkCommandBuffer = ^VkCommandBuffer; + PPVkCommandBuffer = ^PVkCommandBuffer; + + _VkFence = record end; + VkFence = {$IFDEF VK_CPU64}^_VkFence{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkFence = ^VkFence; + PPVkFence = ^PVkFence; + + _VkDeviceMemory = record end; + VkDeviceMemory = {$IFDEF VK_CPU64}^_VkDeviceMemory{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkDeviceMemory = ^VkDeviceMemory; + PPVkDeviceMemory = ^PVkDeviceMemory; + + VkMemoryMapFlags = VkFlags; + PVkMemoryMapFlags = ^VkMemoryMapFlags; + PPVkMemoryMapFlags = ^PVkMemoryMapFlags; + + _VkBuffer = record end; + VkBuffer = {$IFDEF VK_CPU64}^_VkBuffer{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkBuffer = ^VkBuffer; + PPVkBuffer = ^PVkBuffer; + + _VkImage = record end; + VkImage = {$IFDEF VK_CPU64}^_VkImage{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkImage = ^VkImage; + PPVkImage = ^PVkImage; + + VkImageAspectFlags = TVkImageAspectFlagBits; + PVkImageAspectFlags = ^VkImageAspectFlags; + PPVkImageAspectFlags = ^PVkImageAspectFlags; + + VkSparseImageFormatFlags = TVkSparseImageFormatFlagBits; + PVkSparseImageFormatFlags = ^VkSparseImageFormatFlags; + PPVkSparseImageFormatFlags = ^PVkSparseImageFormatFlags; + + VkSparseMemoryBindFlags = TVkSparseMemoryBindFlagBits; + PVkSparseMemoryBindFlags = ^VkSparseMemoryBindFlags; + PPVkSparseMemoryBindFlags = ^PVkSparseMemoryBindFlags; + + VkFenceCreateFlags = TVkFenceCreateFlagBits; + PVkFenceCreateFlags = ^VkFenceCreateFlags; + PPVkFenceCreateFlags = ^PVkFenceCreateFlags; + + VkSemaphoreCreateFlags = VkFlags; + PVkSemaphoreCreateFlags = ^VkSemaphoreCreateFlags; + PPVkSemaphoreCreateFlags = ^PVkSemaphoreCreateFlags; + + VkEventCreateFlags = VkFlags; + PVkEventCreateFlags = ^VkEventCreateFlags; + PPVkEventCreateFlags = ^PVkEventCreateFlags; + + _VkEvent = record end; + VkEvent = {$IFDEF VK_CPU64}^_VkEvent{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkEvent = ^VkEvent; + PPVkEvent = ^PVkEvent; + + VkQueryPoolCreateFlags = VkFlags; + PVkQueryPoolCreateFlags = ^VkQueryPoolCreateFlags; + PPVkQueryPoolCreateFlags = ^PVkQueryPoolCreateFlags; + + VkQueryPipelineStatisticFlags = TVkQueryPipelineStatisticFlagBits; + PVkQueryPipelineStatisticFlags = ^VkQueryPipelineStatisticFlags; + PPVkQueryPipelineStatisticFlags = ^PVkQueryPipelineStatisticFlags; + + _VkQueryPool = record end; + VkQueryPool = {$IFDEF VK_CPU64}^_VkQueryPool{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkQueryPool = ^VkQueryPool; + PPVkQueryPool = ^PVkQueryPool; + + VkQueryResultFlags = TVkQueryResultFlagBits; + PVkQueryResultFlags = ^VkQueryResultFlags; + PPVkQueryResultFlags = ^PVkQueryResultFlags; + + VkBufferCreateFlags = TVkBufferCreateFlagBits; + PVkBufferCreateFlags = ^VkBufferCreateFlags; + PPVkBufferCreateFlags = ^PVkBufferCreateFlags; + + VkBufferUsageFlags = TVkBufferUsageFlagBits; + PVkBufferUsageFlags = ^VkBufferUsageFlags; + PPVkBufferUsageFlags = ^PVkBufferUsageFlags; + + VkBufferViewCreateFlags = VkFlags; + PVkBufferViewCreateFlags = ^VkBufferViewCreateFlags; + PPVkBufferViewCreateFlags = ^PVkBufferViewCreateFlags; + + _VkBufferView = record end; + VkBufferView = {$IFDEF VK_CPU64}^_VkBufferView{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkBufferView = ^VkBufferView; + PPVkBufferView = ^PVkBufferView; + + VkImageViewCreateFlags = VkFlags; + PVkImageViewCreateFlags = ^VkImageViewCreateFlags; + PPVkImageViewCreateFlags = ^PVkImageViewCreateFlags; + + _VkImageView = record end; + VkImageView = {$IFDEF VK_CPU64}^_VkImageView{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkImageView = ^VkImageView; + PPVkImageView = ^PVkImageView; + + VkShaderModuleCreateFlags = VkFlags; + PVkShaderModuleCreateFlags = ^VkShaderModuleCreateFlags; + PPVkShaderModuleCreateFlags = ^PVkShaderModuleCreateFlags; + + _VkShaderModule = record end; + VkShaderModule = {$IFDEF VK_CPU64}^_VkShaderModule{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkShaderModule = ^VkShaderModule; + PPVkShaderModule = ^PVkShaderModule; + + VkPipelineCacheCreateFlags = VkFlags; + PVkPipelineCacheCreateFlags = ^VkPipelineCacheCreateFlags; + PPVkPipelineCacheCreateFlags = ^PVkPipelineCacheCreateFlags; + + _VkPipelineCache = record end; + VkPipelineCache = {$IFDEF VK_CPU64}^_VkPipelineCache{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkPipelineCache = ^VkPipelineCache; + PPVkPipelineCache = ^PVkPipelineCache; + + VkPipelineCreateFlags = TVkPipelineCreateFlagBits; + PVkPipelineCreateFlags = ^VkPipelineCreateFlags; + PPVkPipelineCreateFlags = ^PVkPipelineCreateFlags; + + VkPipelineShaderStageCreateFlags = VkFlags; + PVkPipelineShaderStageCreateFlags = ^VkPipelineShaderStageCreateFlags; + PPVkPipelineShaderStageCreateFlags = ^PVkPipelineShaderStageCreateFlags; + + VkPipelineVertexInputStateCreateFlags = VkFlags; + PVkPipelineVertexInputStateCreateFlags = ^VkPipelineVertexInputStateCreateFlags; + PPVkPipelineVertexInputStateCreateFlags = ^PVkPipelineVertexInputStateCreateFlags; + + VkPipelineInputAssemblyStateCreateFlags = VkFlags; + PVkPipelineInputAssemblyStateCreateFlags = ^VkPipelineInputAssemblyStateCreateFlags; + PPVkPipelineInputAssemblyStateCreateFlags = ^PVkPipelineInputAssemblyStateCreateFlags; + + VkPipelineTessellationStateCreateFlags = VkFlags; + PVkPipelineTessellationStateCreateFlags = ^VkPipelineTessellationStateCreateFlags; + PPVkPipelineTessellationStateCreateFlags = ^PVkPipelineTessellationStateCreateFlags; + + VkPipelineViewportStateCreateFlags = VkFlags; + PVkPipelineViewportStateCreateFlags = ^VkPipelineViewportStateCreateFlags; + PPVkPipelineViewportStateCreateFlags = ^PVkPipelineViewportStateCreateFlags; + + VkPipelineRasterizationStateCreateFlags = VkFlags; + PVkPipelineRasterizationStateCreateFlags = ^VkPipelineRasterizationStateCreateFlags; + PPVkPipelineRasterizationStateCreateFlags = ^PVkPipelineRasterizationStateCreateFlags; + + VkCullModeFlags = TVkCullModeFlagBits; + PVkCullModeFlags = ^VkCullModeFlags; + PPVkCullModeFlags = ^PVkCullModeFlags; + + VkPipelineMultisampleStateCreateFlags = VkFlags; + PVkPipelineMultisampleStateCreateFlags = ^VkPipelineMultisampleStateCreateFlags; + PPVkPipelineMultisampleStateCreateFlags = ^PVkPipelineMultisampleStateCreateFlags; + + VkSampleMask = VkUint32; + PVkSampleMask = ^VkSampleMask; + PPVkSampleMask = ^PVkSampleMask; - TVkSampleCountFlagBits = ( - VK_SAMPLE_COUNT_1_BIT = (1 shl 0), - VK_SAMPLE_COUNT_2_BIT = (1 shl 1), - VK_SAMPLE_COUNT_4_BIT = (1 shl 2), - VK_SAMPLE_COUNT_8_BIT = (1 shl 3), - VK_SAMPLE_COUNT_16_BIT = (1 shl 4), - VK_SAMPLE_COUNT_32_BIT = (1 shl 5), - VK_SAMPLE_COUNT_64_BIT = (1 shl 6) - ); - PVkSampleCountFlagBits = ^TVkSampleCountFlagBits; - PPVkSampleCountFlagBits = ^PVkSampleCountFlagBits; + VkPipelineDepthStencilStateCreateFlags = VkFlags; + PVkPipelineDepthStencilStateCreateFlags = ^VkPipelineDepthStencilStateCreateFlags; + PPVkPipelineDepthStencilStateCreateFlags = ^PVkPipelineDepthStencilStateCreateFlags; - TVkQueryType = ( - VK_QUERY_TYPE_OCCLUSION = 0, - VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, - VK_QUERY_TYPE_TIMESTAMP = 2, - VK_QUERY_TYPE_MAX_ENUM = $7FFFFFFF - ); - PVkQueryType = ^TVkQueryType; - PPVkQueryType = ^PVkQueryType; + VkPipelineColorBlendStateCreateFlags = VkFlags; + PVkPipelineColorBlendStateCreateFlags = ^VkPipelineColorBlendStateCreateFlags; + PPVkPipelineColorBlendStateCreateFlags = ^PVkPipelineColorBlendStateCreateFlags; - TVkSharingMode = ( - VK_SHARING_MODE_EXCLUSIVE = 0, - VK_SHARING_MODE_CONCURRENT = 1, - VK_SHARING_MODE_MAX_ENUM = $7FFFFFFF - ); - PVkSharingMode = ^TVkSharingMode; - PPVkSharingMode = ^PVkSharingMode; + VkColorComponentFlags = TVkColorComponentFlagBits; + PVkColorComponentFlags = ^VkColorComponentFlags; + PPVkColorComponentFlags = ^PVkColorComponentFlags; - TVkImageLayout = ( - VK_IMAGE_LAYOUT_UNDEFINED = 0, - VK_IMAGE_LAYOUT_GENERAL = 1, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, - VK_IMAGE_LAYOUT_PREINITIALIZED = 8, - VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, - VK_IMAGE_LAYOUT_MAX_ENUM = $7FFFFFFF - ); - PVkImageLayout = ^TVkImageLayout; - PPVkImageLayout = ^PVkImageLayout; + VkPipelineDynamicStateCreateFlags = VkFlags; + PVkPipelineDynamicStateCreateFlags = ^VkPipelineDynamicStateCreateFlags; + PPVkPipelineDynamicStateCreateFlags = ^PVkPipelineDynamicStateCreateFlags; - TVkImageViewType = ( - 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_MAX_ENUM = $7FFFFFFF - ); - PVkImageViewType = ^TVkImageViewType; - PPVkImageViewType = ^PVkImageViewType; + _VkPipelineLayout = record end; + VkPipelineLayout = {$IFDEF VK_CPU64}^_VkPipelineLayout{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkPipelineLayout = ^VkPipelineLayout; + PPVkPipelineLayout = ^PVkPipelineLayout; - TVkComponentSwizzle = ( - VK_COMPONENT_SWIZZLE_IDENTITY = 0, - VK_COMPONENT_SWIZZLE_ZERO = 1, - VK_COMPONENT_SWIZZLE_ONE = 2, - VK_COMPONENT_SWIZZLE_R = 3, - VK_COMPONENT_SWIZZLE_G = 4, - VK_COMPONENT_SWIZZLE_B = 5, - VK_COMPONENT_SWIZZLE_A = 6, - VK_COMPONENT_SWIZZLE_MAX_ENUM = $7FFFFFFF - ); - PVkComponentSwizzle = ^TVkComponentSwizzle; - PPVkComponentSwizzle = ^PVkComponentSwizzle; + _VkRenderPass = record end; + VkRenderPass = {$IFDEF VK_CPU64}^_VkRenderPass{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkRenderPass = ^VkRenderPass; + PPVkRenderPass = ^PVkRenderPass; - TVkShaderStageFlagBits = ( - VK_SHADER_STAGE_VERTEX_BIT = (1 shl 0), - VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = (1 shl 1), - VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = (1 shl 2), - VK_SHADER_STAGE_GEOMETRY_BIT = (1 shl 3), - VK_SHADER_STAGE_FRAGMENT_BIT = (1 shl 4), - VK_SHADER_STAGE_COMPUTE_BIT = (1 shl 5), - VK_SHADER_STAGE_ALL_GRAPHICS = $1F, - VK_SHADER_STAGE_ALL = $7FFFFFFF - ); - PVkShaderStageFlagBits = ^TVkShaderStageFlagBits; - PPVkShaderStageFlagBits = ^PVkShaderStageFlagBits; + _VkPipeline = record end; + VkPipeline = {$IFDEF VK_CPU64}^_VkPipeline{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkPipeline = ^VkPipeline; + PPVkPipeline = ^PVkPipeline; - TVkVertexInputRate = ( - VK_VERTEX_INPUT_RATE_VERTEX = 0, - VK_VERTEX_INPUT_RATE_INSTANCE = 1, - VK_VERTEX_INPUT_RATE_MAX_ENUM = $7FFFFFFF - ); - PVkVertexInputRate = ^TVkVertexInputRate; - PPVkVertexInputRate = ^PVkVertexInputRate; + VkPipelineLayoutCreateFlags = VkFlags; + PVkPipelineLayoutCreateFlags = ^VkPipelineLayoutCreateFlags; + PPVkPipelineLayoutCreateFlags = ^PVkPipelineLayoutCreateFlags; - TVkPrimitiveTopology = ( - VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, - VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, - VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = $7FFFFFFF - ); - PVkPrimitiveTopology = ^TVkPrimitiveTopology; - PPVkPrimitiveTopology = ^PVkPrimitiveTopology; + _VkDescriptorSetLayout = record end; + VkDescriptorSetLayout = {$IFDEF VK_CPU64}^_VkDescriptorSetLayout{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkDescriptorSetLayout = ^VkDescriptorSetLayout; + PPVkDescriptorSetLayout = ^PVkDescriptorSetLayout; - TVkPolygonMode = ( - VK_POLYGON_MODE_FILL = 0, - VK_POLYGON_MODE_LINE = 1, - VK_POLYGON_MODE_POINT = 2, - VK_POLYGON_MODE_MAX_ENUM = $7FFFFFFF - ); - PVkPolygonMode = ^TVkPolygonMode; - PPVkPolygonMode = ^PVkPolygonMode; + VkShaderStageFlags = TVkShaderStageFlagBits; + PVkShaderStageFlags = ^VkShaderStageFlags; + PPVkShaderStageFlags = ^PVkShaderStageFlags; - TVkFrontFace = ( - VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, - VK_FRONT_FACE_CLOCKWISE = 1, - VK_FRONT_FACE_MAX_ENUM = $7FFFFFFF - ); - PVkFrontFace = ^TVkFrontFace; - PPVkFrontFace = ^PVkFrontFace; + VkSamplerCreateFlags = VkFlags; + PVkSamplerCreateFlags = ^VkSamplerCreateFlags; + PPVkSamplerCreateFlags = ^PVkSamplerCreateFlags; - TVkCompareOp = ( - VK_COMPARE_OP_NEVER = 0, - VK_COMPARE_OP_LESS = 1, - VK_COMPARE_OP_EQUAL = 2, - VK_COMPARE_OP_LESS_OR_EQUAL = 3, - VK_COMPARE_OP_GREATER = 4, - VK_COMPARE_OP_NOT_EQUAL = 5, - VK_COMPARE_OP_GREATER_OR_EQUAL = 6, - VK_COMPARE_OP_ALWAYS = 7, - VK_COMPARE_OP_MAX_ENUM = $7FFFFFFF - ); - PVkCompareOp = ^TVkCompareOp; - PPVkCompareOp = ^PVkCompareOp; + _VkSampler = record end; + VkSampler = {$IFDEF VK_CPU64}^_VkSampler{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkSampler = ^VkSampler; + PPVkSampler = ^PVkSampler; - TVkStencilOp = ( - VK_STENCIL_OP_KEEP = 0, - VK_STENCIL_OP_ZERO = 1, - VK_STENCIL_OP_REPLACE = 2, - VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, - VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, - VK_STENCIL_OP_INVERT = 5, - VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, - VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, - VK_STENCIL_OP_MAX_ENUM = $7FFFFFFF - ); - PVkStencilOp = ^TVkStencilOp; - PPVkStencilOp = ^PVkStencilOp; + VkDescriptorSetLayoutCreateFlags = VkFlags; + PVkDescriptorSetLayoutCreateFlags = ^VkDescriptorSetLayoutCreateFlags; + PPVkDescriptorSetLayoutCreateFlags = ^PVkDescriptorSetLayoutCreateFlags; - TVkLogicOp = ( - VK_LOGIC_OP_CLEAR = 0, - VK_LOGIC_OP_AND = 1, - VK_LOGIC_OP_AND_REVERSE = 2, - VK_LOGIC_OP_COPY = 3, - VK_LOGIC_OP_AND_INVERTED = 4, - VK_LOGIC_OP_NO_OP = 5, - VK_LOGIC_OP_XOR = 6, - VK_LOGIC_OP_OR = 7, - VK_LOGIC_OP_NOR = 8, - VK_LOGIC_OP_EQUIVALENT = 9, - VK_LOGIC_OP_INVERT = 10, - VK_LOGIC_OP_OR_REVERSE = 11, - VK_LOGIC_OP_COPY_INVERTED = 12, - VK_LOGIC_OP_OR_INVERTED = 13, - VK_LOGIC_OP_NAND = 14, - VK_LOGIC_OP_SET = 15, - VK_LOGIC_OP_MAX_ENUM = $7FFFFFFF - ); - PVkLogicOp = ^TVkLogicOp; - PPVkLogicOp = ^PVkLogicOp; + VkDescriptorPoolCreateFlags = TVkDescriptorPoolCreateFlagBits; + PVkDescriptorPoolCreateFlags = ^VkDescriptorPoolCreateFlags; + PPVkDescriptorPoolCreateFlags = ^PVkDescriptorPoolCreateFlags; - TVkBlendFactor = ( - VK_BLEND_FACTOR_ZERO = 0, - VK_BLEND_FACTOR_ONE = 1, - VK_BLEND_FACTOR_SRC_COLOR = 2, - VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, - VK_BLEND_FACTOR_DST_COLOR = 4, - VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, - VK_BLEND_FACTOR_SRC_ALPHA = 6, - VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, - VK_BLEND_FACTOR_DST_ALPHA = 8, - VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, - VK_BLEND_FACTOR_CONSTANT_COLOR = 10, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, - VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, - VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, - VK_BLEND_FACTOR_SRC1_COLOR = 15, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, - VK_BLEND_FACTOR_SRC1_ALPHA = 17, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, - VK_BLEND_FACTOR_MAX_ENUM = $7FFFFFFF - ); - PVkBlendFactor = ^TVkBlendFactor; - PPVkBlendFactor = ^PVkBlendFactor; + _VkDescriptorPool = record end; + VkDescriptorPool = {$IFDEF VK_CPU64}^_VkDescriptorPool{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkDescriptorPool = ^VkDescriptorPool; + PPVkDescriptorPool = ^PVkDescriptorPool; - TVkBlendOp = ( - 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_MAX_ENUM = $7FFFFFFF - ); - PVkBlendOp = ^TVkBlendOp; - PPVkBlendOp = ^PVkBlendOp; + VkDescriptorPoolResetFlags = VkFlags; + PVkDescriptorPoolResetFlags = ^VkDescriptorPoolResetFlags; + PPVkDescriptorPoolResetFlags = ^PVkDescriptorPoolResetFlags; - TVkDynamicState = ( - VK_DYNAMIC_STATE_VIEWPORT = 0, - VK_DYNAMIC_STATE_SCISSOR = 1, - VK_DYNAMIC_STATE_LINE_WIDTH = 2, - VK_DYNAMIC_STATE_DEPTH_BIAS = 3, - VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, - VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, - VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, - VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, - VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, - VK_DYNAMIC_STATE_MAX_ENUM = $7FFFFFFF - ); - PVkDynamicState = ^TVkDynamicState; - PPVkDynamicState = ^PVkDynamicState; + _VkDescriptorSet = record end; + VkDescriptorSet = {$IFDEF VK_CPU64}^_VkDescriptorSet{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkDescriptorSet = ^VkDescriptorSet; + PPVkDescriptorSet = ^PVkDescriptorSet; - TVkFilter = ( - VK_FILTER_NEAREST = 0, - VK_FILTER_LINEAR = 1, - VK_FILTER_MAX_ENUM = $7FFFFFFF - ); - PVkFilter = ^TVkFilter; - PPVkFilter = ^PVkFilter; + VkFramebufferCreateFlags = VkFlags; + PVkFramebufferCreateFlags = ^VkFramebufferCreateFlags; + PPVkFramebufferCreateFlags = ^PVkFramebufferCreateFlags; + + _VkFramebuffer = record end; + VkFramebuffer = {$IFDEF VK_CPU64}^_VkFramebuffer{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkFramebuffer = ^VkFramebuffer; + PPVkFramebuffer = ^PVkFramebuffer; - TVkSamplerMipmapMode = ( - VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, - VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, - VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = $7FFFFFFF - ); - PVkSamplerMipmapMode = ^TVkSamplerMipmapMode; - PPVkSamplerMipmapMode = ^PVkSamplerMipmapMode; + VkRenderPassCreateFlags = VkFlags; + PVkRenderPassCreateFlags = ^VkRenderPassCreateFlags; + PPVkRenderPassCreateFlags = ^PVkRenderPassCreateFlags; - TVkSamplerAddressMode = ( - VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, - VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, - VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, - VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = $7FFFFFFF - ); - PVkSamplerAddressMode = ^TVkSamplerAddressMode; - PPVkSamplerAddressMode = ^PVkSamplerAddressMode; + VkAttachmentDescriptionFlags = TVkAttachmentDescriptionFlagBits; + PVkAttachmentDescriptionFlags = ^VkAttachmentDescriptionFlags; + PPVkAttachmentDescriptionFlags = ^PVkAttachmentDescriptionFlags; - TVkBorderColor = ( - 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_MAX_ENUM = $7FFFFFFF - ); - PVkBorderColor = ^TVkBorderColor; - PPVkBorderColor = ^PVkBorderColor; + VkSubpassDescriptionFlags = VkFlags; + PVkSubpassDescriptionFlags = ^VkSubpassDescriptionFlags; + PPVkSubpassDescriptionFlags = ^PVkSubpassDescriptionFlags; - TVkDescriptorType = ( - VK_DESCRIPTOR_TYPE_SAMPLER = 0, - VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, - VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, - VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, - VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, - VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, - VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, - VK_DESCRIPTOR_TYPE_MAX_ENUM = $7FFFFFFF - ); - PVkDescriptorType = ^TVkDescriptorType; - PPVkDescriptorType = ^PVkDescriptorType; + VkAccessFlags = TVkAccessFlagBits; + PVkAccessFlags = ^VkAccessFlags; + PPVkAccessFlags = ^PVkAccessFlags; - TVkAttachmentLoadOp = ( - VK_ATTACHMENT_LOAD_OP_LOAD = 0, - VK_ATTACHMENT_LOAD_OP_CLEAR = 1, - VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, - VK_ATTACHMENT_LOAD_OP_MAX_ENUM = $7FFFFFFF - ); - PVkAttachmentLoadOp = ^TVkAttachmentLoadOp; - PPVkAttachmentLoadOp = ^PVkAttachmentLoadOp; + VkDependencyFlags = TVkDependencyFlagBits; + PVkDependencyFlags = ^VkDependencyFlags; + PPVkDependencyFlags = ^PVkDependencyFlags; - TVkAttachmentStoreOp = ( - VK_ATTACHMENT_STORE_OP_STORE = 0, - VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, - VK_ATTACHMENT_STORE_OP_MAX_ENUM = $7FFFFFFF - ); - PVkAttachmentStoreOp = ^TVkAttachmentStoreOp; - PPVkAttachmentStoreOp = ^PVkAttachmentStoreOp; + VkCommandPoolCreateFlags = TVkCommandPoolCreateFlagBits; + PVkCommandPoolCreateFlags = ^VkCommandPoolCreateFlags; + PPVkCommandPoolCreateFlags = ^PVkCommandPoolCreateFlags; - TVkPipelineBindPoint = ( - VK_PIPELINE_BIND_POINT_GRAPHICS = 0, - VK_PIPELINE_BIND_POINT_COMPUTE = 1, - VK_PIPELINE_BIND_POINT_MAX_ENUM = $7FFFFFFF - ); - PVkPipelineBindPoint = ^TVkPipelineBindPoint; - PPVkPipelineBindPoint = ^PVkPipelineBindPoint; + VkCommandPoolResetFlags = TVkCommandPoolResetFlagBits; + PVkCommandPoolResetFlags = ^VkCommandPoolResetFlags; + PPVkCommandPoolResetFlags = ^PVkCommandPoolResetFlags; - TVkCommandBufferLevel = ( - VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, - VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, - VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = $7FFFFFFF - ); - PVkCommandBufferLevel = ^TVkCommandBufferLevel; - PPVkCommandBufferLevel = ^PVkCommandBufferLevel; + VkCommandBufferUsageFlags = TVkCommandBufferUsageFlagBits; + PVkCommandBufferUsageFlags = ^VkCommandBufferUsageFlags; + PPVkCommandBufferUsageFlags = ^PVkCommandBufferUsageFlags; - TVkIndexType = ( - VK_INDEX_TYPE_UINT16 = 0, - VK_INDEX_TYPE_UINT32 = 1, - VK_INDEX_TYPE_MAX_ENUM = $7FFFFFFF - ); - PVkIndexType = ^TVkIndexType; - PPVkIndexType = ^PVkIndexType; + VkQueryControlFlags = TVkQueryControlFlagBits; + PVkQueryControlFlags = ^VkQueryControlFlags; + PPVkQueryControlFlags = ^PVkQueryControlFlags; - TVkPipelineStageFlagBits = ( - VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = (1 shl 0), - VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = (1 shl 1), - VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = (1 shl 2), - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = (1 shl 3), - VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = (1 shl 4), - VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = (1 shl 5), - VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = (1 shl 6), - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = (1 shl 7), - VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = (1 shl 8), - VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = (1 shl 9), - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = (1 shl 10), - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = (1 shl 11), - VK_PIPELINE_STAGE_TRANSFER_BIT = (1 shl 12), - VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = (1 shl 13), - VK_PIPELINE_STAGE_HOST_BIT = (1 shl 14), - VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = (1 shl 15), - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = (1 shl 16) - ); - PVkPipelineStageFlagBits = ^TVkPipelineStageFlagBits; - PPVkPipelineStageFlagBits = ^PVkPipelineStageFlagBits; + VkCommandBufferResetFlags = TVkCommandBufferResetFlagBits; + PVkCommandBufferResetFlags = ^VkCommandBufferResetFlags; + PPVkCommandBufferResetFlags = ^PVkCommandBufferResetFlags; - TVkSubpassContents = ( - VK_SUBPASS_CONTENTS_INLINE = 0, - VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, - VK_SUBPASS_CONTENTS_MAX_ENUM = $7FFFFFFF - ); - PVkSubpassContents = ^TVkSubpassContents; - PPVkSubpassContents = ^PVkSubpassContents; + VkStencilFaceFlags = TVkStencilFaceFlagBits; + PVkStencilFaceFlags = ^VkStencilFaceFlags; + PPVkStencilFaceFlags = ^PVkStencilFaceFlags; { ========================================== VK_KHR_surface ========================================== } - TVkSurfaceTransformFlagBitsKHR = ( - VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = (1 shl 0), - VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = (1 shl 1), - VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = (1 shl 2), - VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = (1 shl 3), - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = (1 shl 4), - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = (1 shl 5), - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = (1 shl 6), - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = (1 shl 7), - VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = (1 shl 8) - ); - PVkSurfaceTransformFlagBitsKHR = ^TVkSurfaceTransformFlagBitsKHR; - PPVkSurfaceTransformFlagBitsKHR = ^PVkSurfaceTransformFlagBitsKHR; + _VkSurfaceKHR = record end; + VkSurfaceKHR = {$IFDEF VK_CPU64}^_VkSurfaceKHR{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkSurfaceKHR = ^VkSurfaceKHR; + PPVkSurfaceKHR = ^PVkSurfaceKHR; - TVkColorSpaceKHR = ( - VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0, - VK_COLORSPACE_MAX_ENUM = $7FFFFFFF - ); - PVkColorSpaceKHR = ^TVkColorSpaceKHR; - PPVkColorSpaceKHR = ^PVkColorSpaceKHR; + VkSurfaceTransformFlagsKHR = TVkSurfaceTransformFlagBitsKHR; + PVkSurfaceTransformFlagsKHR = ^VkSurfaceTransformFlagsKHR; + PPVkSurfaceTransformFlagsKHR = ^PVkSurfaceTransformFlagsKHR; - TVkPresentModeKHR = ( - VK_PRESENT_MODE_IMMEDIATE_KHR = 0, - VK_PRESENT_MODE_MAILBOX_KHR = 1, - VK_PRESENT_MODE_FIFO_KHR = 2, - VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, - VK_PRESENT_MODE_MAX_ENUM = $7FFFFFFF - ); - PVkPresentModeKHR = ^TVkPresentModeKHR; - PPVkPresentModeKHR = ^PVkPresentModeKHR; + VkCompositeAlphaFlagsKHR = TVkCompositeAlphaFlagBitsKHR; + PVkCompositeAlphaFlagsKHR = ^VkCompositeAlphaFlagsKHR; + PPVkCompositeAlphaFlagsKHR = ^PVkCompositeAlphaFlagsKHR; { ========================================= VK_KHR_swapchain ========================================= } - TVkCompositeAlphaFlagBitsKHR = ( - VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = (1 shl 0), - VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = (1 shl 1), - VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = (1 shl 2), - VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = (1 shl 3) - ); - PVkCompositeAlphaFlagBitsKHR = ^TVkCompositeAlphaFlagBitsKHR; - PPVkCompositeAlphaFlagBitsKHR = ^PVkCompositeAlphaFlagBitsKHR; + VkSwapchainCreateFlagsKHR = VkFlags; + PVkSwapchainCreateFlagsKHR = ^VkSwapchainCreateFlagsKHR; + PPVkSwapchainCreateFlagsKHR = ^PVkSwapchainCreateFlagsKHR; + + _VkSwapchainKHR = record end; + VkSwapchainKHR = {$IFDEF VK_CPU64}^_VkSwapchainKHR{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkSwapchainKHR = ^VkSwapchainKHR; + PPVkSwapchainKHR = ^PVkSwapchainKHR; { ========================================== VK_KHR_display ========================================== } - TVkDisplayPlaneAlphaFlagBitsKHR = ( - VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = (1 shl 0), - VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = (1 shl 1), - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = (1 shl 2), - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = (1 shl 3) - ); - PVkDisplayPlaneAlphaFlagBitsKHR = ^TVkDisplayPlaneAlphaFlagBitsKHR; - PPVkDisplayPlaneAlphaFlagBitsKHR = ^PVkDisplayPlaneAlphaFlagBitsKHR; + _VkDisplayKHR = record end; + VkDisplayKHR = {$IFDEF VK_CPU64}^_VkDisplayKHR{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkDisplayKHR = ^VkDisplayKHR; + PPVkDisplayKHR = ^PVkDisplayKHR; + + _VkDisplayModeKHR = record end; + VkDisplayModeKHR = {$IFDEF VK_CPU64}^_VkDisplayModeKHR{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkDisplayModeKHR = ^VkDisplayModeKHR; + PPVkDisplayModeKHR = ^PVkDisplayModeKHR; + + VkDisplayModeCreateFlagsKHR = VkFlags; + PVkDisplayModeCreateFlagsKHR = ^VkDisplayModeCreateFlagsKHR; + PPVkDisplayModeCreateFlagsKHR = ^PVkDisplayModeCreateFlagsKHR; + + VkDisplayPlaneAlphaFlagsKHR = TVkDisplayPlaneAlphaFlagBitsKHR; + PVkDisplayPlaneAlphaFlagsKHR = ^VkDisplayPlaneAlphaFlagsKHR; + PPVkDisplayPlaneAlphaFlagsKHR = ^PVkDisplayPlaneAlphaFlagsKHR; + + VkDisplaySurfaceCreateFlagsKHR = VkFlags; + PVkDisplaySurfaceCreateFlagsKHR = ^VkDisplaySurfaceCreateFlagsKHR; + PPVkDisplaySurfaceCreateFlagsKHR = ^PVkDisplaySurfaceCreateFlagsKHR; + +{ ======================================= VK_KHR_xlib_surface ======================================== } +{$IFDEF VK_USE_PLATFORM_XLIB_KHR} + VkXlibSurfaceCreateFlagsKHR = VkFlags; + PVkXlibSurfaceCreateFlagsKHR = ^VkXlibSurfaceCreateFlagsKHR; + PPVkXlibSurfaceCreateFlagsKHR = ^PVkXlibSurfaceCreateFlagsKHR; +{$ENDIF} + +{ ======================================== VK_KHR_xcb_surface ======================================== } +{$IFDEF VK_USE_PLATFORM_XCB_KHR} + VkXcbSurfaceCreateFlagsKHR = VkFlags; + PVkXcbSurfaceCreateFlagsKHR = ^VkXcbSurfaceCreateFlagsKHR; + PPVkXcbSurfaceCreateFlagsKHR = ^PVkXcbSurfaceCreateFlagsKHR; +{$ENDIF} + +{ ====================================== VK_KHR_wayland_surface ====================================== } +{$IFDEF VK_USE_PLATFORM_WAYLAND_KHR} + VkWaylandSurfaceCreateFlagsKHR = VkFlags; + PVkWaylandSurfaceCreateFlagsKHR = ^VkWaylandSurfaceCreateFlagsKHR; + PPVkWaylandSurfaceCreateFlagsKHR = ^PVkWaylandSurfaceCreateFlagsKHR; +{$ENDIF} + +{ ======================================== VK_KHR_mir_surface ======================================== } +{$IFDEF VK_USE_PLATFORM_MIR_KHR} + VkMirSurfaceCreateFlagsKHR = VkFlags; + PVkMirSurfaceCreateFlagsKHR = ^VkMirSurfaceCreateFlagsKHR; + PPVkMirSurfaceCreateFlagsKHR = ^PVkMirSurfaceCreateFlagsKHR; +{$ENDIF} + +{ ====================================== VK_KHR_android_surface ====================================== } +{$IFDEF VK_USE_PLATFORM_ANDROID_KHR} + VkAndroidSurfaceCreateFlagsKHR = VkFlags; + PVkAndroidSurfaceCreateFlagsKHR = ^VkAndroidSurfaceCreateFlagsKHR; + PPVkAndroidSurfaceCreateFlagsKHR = ^PVkAndroidSurfaceCreateFlagsKHR; +{$ENDIF} + +{ ======================================= VK_KHR_win32_surface ======================================= } +{$IFDEF VK_USE_PLATFORM_WIN32_KHR} + VkWin32SurfaceCreateFlagsKHR = VkFlags; + PVkWin32SurfaceCreateFlagsKHR = ^VkWin32SurfaceCreateFlagsKHR; + PPVkWin32SurfaceCreateFlagsKHR = ^PVkWin32SurfaceCreateFlagsKHR; +{$ENDIF} { ======================================= VK_EXT_debug_report ======================================== } - TVkDebugReportObjectTypeEXT = ( - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, - VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, - VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, - VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, - VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, - VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, - VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, - VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, - VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, - VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, - VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, - VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, - VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28 - ); - PVkDebugReportObjectTypeEXT = ^TVkDebugReportObjectTypeEXT; - PPVkDebugReportObjectTypeEXT = ^PVkDebugReportObjectTypeEXT; + VkDebugReportFlagsEXT = TVkDebugReportFlagBitsEXT; + PVkDebugReportFlagsEXT = ^VkDebugReportFlagsEXT; + PPVkDebugReportFlagsEXT = ^PVkDebugReportFlagsEXT; - TVkDebugReportErrorEXT = ( - VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, - VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1 - ); - PVkDebugReportErrorEXT = ^TVkDebugReportErrorEXT; - PPVkDebugReportErrorEXT = ^PVkDebugReportErrorEXT; + _VkDebugReportCallbackEXT = record end; + VkDebugReportCallbackEXT = {$IFDEF VK_CPU64}^_VkDebugReportCallbackEXT{$ELSE}VkNonDispatchableHandle{$ENDIF}; + PVkDebugReportCallbackEXT = ^VkDebugReportCallbackEXT; + PPVkDebugReportCallbackEXT = ^PVkDebugReportCallbackEXT; type { function pointers } @@ -4226,6 +4482,32 @@ var vkEnumerateInstanceExtensionProperties: TvkEnumerateInstanceExtensionProperties; vkEnumerateInstanceLayerProperties: TvkEnumerateInstanceLayerProperties; +const { predefined flags / sets } + VK_SHADER_STAGE_ALL_GRAPHICS: TVkShaderStageFlagBits = [ + VK_SHADER_STAGE_VERTEX_BIT, + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, + VK_SHADER_STAGE_GEOMETRY_BIT, + VK_SHADER_STAGE_FRAGMENT_BIT + ]; + VK_SHADER_STAGE_ALL: TVkShaderStageFlagBits = [ + VK_SHADER_STAGE_VERTEX_BIT, + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, + VK_SHADER_STAGE_GEOMETRY_BIT, + VK_SHADER_STAGE_FRAGMENT_BIT, + VK_SHADER_STAGE_COMPUTE_BIT + ]; + VK_CULL_MODE_NONE: TVkCullModeFlagBits = [ ]; + VK_CULL_MODE_FRONT_AND_BACK: TVkCullModeFlagBits = [ + VK_CULL_MODE_FRONT_BIT, + VK_CULL_MODE_BACK_BIT + ]; + VK_STENCIL_FRONT_AND_BACK: TVkStencilFaceFlagBits = [ + VK_STENCIL_FACE_FRONT_BIT, + VK_STENCIL_FACE_BACK_BIT + ]; + type TVkInstanceCommands = class Instance: VkInstance; diff --git a/projects/generator/HeaderGenerator.pas b/projects/generator/HeaderGenerator.pas index 1c6b27c..897c809 100644 --- a/projects/generator/HeaderGenerator.pas +++ b/projects/generator/HeaderGenerator.pas @@ -98,13 +98,17 @@ type private fParent: WideString; fAlias: WideString; + fBitmask: Boolean; + fRequires: WideString; protected function GetDependencyOrder: Integer; override; procedure GenPascalName(var aName: WideString; const aPointer: Integer; const aArrSize: WideString); override; public property Parent: WideString read fParent write fParent; property Alias: WideString read fAlias write fAlias; - + property BitMask: Boolean read fBitmask write fBitmask; + property Requires: WideString read fRequires write fRequires; + procedure ReadXml(const xml: TDOMNode); override; procedure GenerateCode(const aCode: TStringTree); override; end; @@ -112,6 +116,7 @@ type TvkType = class(TvkTypeBase) public procedure ReadXml(const xml: TDOMNode); override; + procedure GenerateCode(const aCode: TStringTree); override; constructor Create; end; @@ -208,11 +213,13 @@ type TValueList = specialize TutlList; private fExpands: WideString; + fBitmask: Boolean; fValues: TValueList; protected procedure GenPascalName(var aName: WideString; const aPointer: Integer; const aArrSize: WideString); override; public property Expands: WideString read fExpands write fExpands; + property Bitmask: Boolean read fBitmask write fBitmask; property Values: TValueList read fValues; procedure ReadXml(const xml: TDOMNode); override; procedure GenerateCode(const aCode: TStringTree); override; @@ -276,6 +283,7 @@ const KEYWORD_COMMENT = 'COMMENT'; KEYWORD_VAR = 'VAR'; KEYWORD_CODE = 'CODE'; + KEYWORD_SETS = 'SETS'; KEYWORD_INSTANCE_COMMANDS = 'INSTANCE_COMMANDS'; KEYWORD_DEVICE_COMMANDS = 'DEVICE_COMMANDS'; @@ -304,19 +312,24 @@ begin try result := Unassigned; - rx.Expression := '^-?([0-9]+)$'; - if rx.Exec(s) then + rx.Expression := '^-?\s*([0-9]+)\s*$'; + if rx.Exec(s) then begin result := StrToInt(rx.Match[0]); + exit; + end; rx.Expression := '^0x([0-9A-Fa-f]+)$'; - if rx.Exec(s) then + if rx.Exec(s) then begin result := '$' + rx.Match[1]; + exit; + end; rx.Expression := '^([0-9\.]+)(f|d)?$'; if rx.Exec(s) then begin result := StrToFloat(rx.Match[1], f); if (rx.Match[2] = 'd') then result := Double(result); + exit; end; rx.Expression := '^\(~0U([L]*)\)$'; @@ -839,27 +852,24 @@ begin inherited GenPascalName(aName, aPointer, aArrSize); end; +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure THeaderGenerator.TvkTypeBase.ReadXml(const xml: TDOMNode); +begin + inherited ReadXml(xml); + fRequires := GetNodeAttrib(xml, 'requires', ''); + fBitmask := (GetNodeAttrib(xml, 'category', '') = 'bitmask'); +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure THeaderGenerator.TvkTypeBase.GenerateCode(const aCode: TStringTree); -var st: TStringTree; begin inherited GenerateCode(aCode); - if Assigned(fList) and (fParent <> '') then fList.GenerateCode(fParent, aCode); if Assigned(fList) and (fAlias <> '') then fList.GenerateCode(fAlias, aCode); - - st := aCode.GetOrCreateItem(KEYWORD_INTF).GetOrCreateItem(KEYWORD_TYPES); - if (st.LinesBefore.Count = 0) then - st.LinesBefore.Add('type { simple types }'); - st := st.GetOrCreateItem(String(fName)); - if (st.LinesBefore.Count = 0) and (fParent <> '') and Assigned(List) then begin - st.LinesBefore.Add(Format(' %-62s = %s;', [ fName, List.GetPascalName(fParent, 0) ])); - st.LinesBefore.Add(Format(' P%-61s = ^%0:s;', [ fName ])); - st.LinesBefore.Add(Format(' PP%-60s = ^P%0:s;', [ fName ])); - st.LinesBefore.Add(''); - end; + if Assigned(fList) and (fRequires <> '') then + fList.GenerateCode(fRequires, aCode); end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -872,6 +882,29 @@ begin Parent := GetNodeValue(xml, 'type'); end; +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure THeaderGenerator.TvkType.GenerateCode(const aCode: TStringTree); +var + st: TStringTree; + n: String; +begin + inherited GenerateCode(aCode); + + st := aCode.GetOrCreateItem(KEYWORD_INTF).GetOrCreateItem(KEYWORD_TYPES); + if (st.LinesBefore.Count = 0) then + st.LinesBefore.Add('type { simple types }'); + st := st.GetOrCreateItem(String(fName)); + n := List.GetPascalName(fParent, 0); + if fBitmask and (fRequires <> '') then + n := 'T' + fRequires; + if (st.LinesBefore.Count = 0) and (fParent <> '') and Assigned(List) then begin + st.LinesBefore.Add(Format(' %-62s = %s;', [ fName, n ])); + st.LinesBefore.Add(Format(' P%-61s = ^%0:s;', [ fName ])); + st.LinesBefore.Add(Format(' PP%-60s = ^P%0:s;', [ fName ])); + st.LinesBefore.Add(''); + end; +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor THeaderGenerator.TvkType.Create; begin @@ -901,10 +934,7 @@ var st: TStringTree; s: String; begin - if Assigned(fList) and (fParent <> '') then - fList.GenerateCode(fParent, aCode); - if Assigned(fList) and (fAlias <> '') then - fList.GenerateCode(fAlias, aCode); + inherited GenerateCode(aCode); st := aCode.GetOrCreateItem(KEYWORD_INTF).GetOrCreateItem(KEYWORD_TYPES); if (st.LinesBefore.Count = 0) then @@ -1383,9 +1413,11 @@ procedure THeaderGenerator.TvkEnum.ReadXml(const xml: TDOMNode); var x, p: TDOMNode; v: TValue; + i: Integer; begin - Name := GetNodeAttrib(xml, 'name'); - Expands := GetNodeAttrib(xml, 'expand', ''); + Name := GetNodeAttrib(xml, 'name'); + Expands := GetNodeAttrib(xml, 'expand', ''); + Bitmask := (GetNodeAttrib(xml, 'type', '') = 'bitmask'); x := xml.FirstChild; while Assigned(x) do begin if (x.NodeName = 'enum') then begin @@ -1407,6 +1439,16 @@ begin if (v.Value = Unassigned) then raise XmlException.Create(WideString('invalid enum value (' + p.TextContent + ')'), xml); + if (Expands <> '') then begin + i := 1; + while (i <= Length(Expands)) and (i <= Length(v.Name)) and (v.Name[i] = Expands[i]) do + inc(i); + if (i <= Length(Expands)) and (Expands[i] = '_') then + dec(i); + Expands := copy(Expands, 1, i-1); + end else + Expands := v.Name; + Values.Add(v); except FreeAndNil(v); @@ -1420,10 +1462,11 @@ end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure THeaderGenerator.TvkEnum.GenerateCode(const aCode: TStringTree); var - st, vt: TStringTree; + st, st2, vt: TStringTree; + s, bitName, s2: String; i: Integer; - v: TValue; - postfix: String; + tmp: QWord; + v, v2: TValue; begin inherited GenerateCode(aCode); st := aCode @@ -1433,22 +1476,56 @@ begin st.LinesBefore.Add('type { enumerations }'); st := st.GetOrCreateItem(String(fName)); if (st.LinesBefore.Count = 0) then begin - st.LinesBefore.Add(Format(' %s = (', [GetPascalName(0, '')])); - postfix := ','; + bitName := GetPascalName(0, ''); + if fBitmask then + bitName := StringReplace(bitName, 'Bits', 'Bit', [rfReplaceAll]); + st.LinesBefore.Add(Format(' %s = (', [bitName])); vt := st.GetOrCreateItem(KEYWORD_ENUM_VALUES); + s := ''; for i := 0 to fValues.Count-1 do begin v := fValues[i]; - if (i = fValues.Count-1) and (fExpands = '') then - postfix := ''; - if (v.IsBit) - then vt.LinesBefore.Add(Format(' %-60s = (1 shl %s)%s', [v.Name, v.Value, postfix])) - else vt.LinesBefore.Add(Format(' %-60s = %s%s', [v.Name, v.Value, postfix])); + if not v.IsBit and fBitmask then begin + st2 := aCode + .GetOrCreateItem(KEYWORD_INTF) + .GetOrCreateItem(KEYWORD_SETS); + if (st2.LinesBefore.Count = 0) then + st2.LinesBefore.Add('const { predefined flags / sets }'); + st2 := st2.GetOrCreateItem(v.Name); + if (st2.LinesBefore.Count = 0) then begin + tmp := StrToInt(v.Value); + s2 := ''; + for v2 in fValues do begin + if v2.IsBit and ((tmp and (1 shl v2.Value)) <> 0) then begin + if (s2 <> '') then + s2 := s2 + ',' + sLineBreak; + s2 := s2 + ' ' + v2.Name; + end; + end; + if (s2 <> '') then + s2 := sLineBreak + s2 + sLineBreak; + st2.LinesBefore.Text := Format(' %s: %s = [' + + '%s' + + ' ];', [v.Name, GetPascalName(0, ''), s2]); + end; + end else begin + if (s <> '') then + s := s + ',' + sLineBreak; + s := s + Format(' %-60s = %s', [v.Name, v.Value]); + end; end; - if (fExpands <> '') then - st.LinesAfter.Add(Format(' %-60s = %s', [fExpands + '_MAX_ENUM', '$7FFFFFFF'])); + if (fExpands <> '') then begin + if fBitmask + then s := s + ',' + sLineBreak + Format(' %-60s = 31', [fExpands+'MAX_BIT']) + else s := s + ',' + sLineBreak + Format(' %-60s = %s', [fExpands + '_MAX_ENUM', '$7FFFFFFF']); + end; + + vt.LinesBefore.Text := s; st.LinesAfter.Add(' );'); - st.LinesAfter.Add(' P%s = ^T%0:s;', [ fName ]); - st.LinesAfter.Add(' PP%s = ^P%0:s;', [ fName ]); + if not fBitmask then begin + st.LinesAfter.Add(' P%s = ^T%0:s;', [ fName ]); + st.LinesAfter.Add(' PP%s = ^P%0:s;', [ fName ]); + end else + st.LinesAfter.Add(' %s = set of %s;', [ GetPascalName(0, ''), bitName ]); st.LinesAfter.Add(''); end; end; @@ -1531,8 +1608,8 @@ var procedure UpdateComments; begin UpdateComment([KEYWORD_INTF, KEYWORD_CONST]); - UpdateComment([KEYWORD_INTF, KEYWORD_TYPES]); UpdateComment([KEYWORD_INTF, KEYWORD_ENUM]); + UpdateComment([KEYWORD_INTF, KEYWORD_TYPES]); UpdateComment([KEYWORD_INTF, KEYWORD_FUNCPTR]); UpdateComment([KEYWORD_INTF, KEYWORD_STRUCT]); UpdateComment([KEYWORD_INTF, KEYWORD_COMMAND]); @@ -1604,6 +1681,7 @@ var value: WideString; offset: Integer; s: String; + i: Integer; c: TvkConst; begin result := false; @@ -1615,12 +1693,17 @@ var offset := 1000000000 + 1000 * (CurrentNumber-1) + offset; if (GetNodeAttrib(xml, 'dir', '') = '-') then offset := -1 * offset; - Code + with Code .GetOrCreateItem(KEYWORD_INTF) .GetOrCreateItem(KEYWORD_ENUM) .GetOrCreateItem(String(ex)) - .GetOrCreateItem(KEYWORD_ENUM_VALUES) - .LinesBefore.Add(Format(' %-60s = %s,', [name, IntToStr(offset)])); + .GetOrCreateItem(KEYWORD_ENUM_VALUES) do + begin + i := LinesBefore.Count-1; + if (i >= 0) and (Pos('MAX_ENUM', LinesBefore[i]) > 0) then + dec(i); + LinesBefore.Insert(i+1, Format(' %-60s = %s,', [name, IntToStr(offset)])); + end; end else begin if not TryGetNodeAttrib(xml, 'value', value) then exit; @@ -1802,8 +1885,8 @@ begin Code.GetOrCreateItem(KEYWORD_COMMENT).LinesBefore.Text := Trim(String(fComment)); with Code.GetOrCreateItem(KEYWORD_INTF) do begin GetOrCreateItem(KEYWORD_CONST).LinesAfter.Add(''); - GetOrCreateItem(KEYWORD_TYPES).LinesAfter.Add(''); GetOrCreateItem(KEYWORD_ENUM).LinesAfter.Add(''); + GetOrCreateItem(KEYWORD_TYPES).LinesAfter.Add(''); GetOrCreateItem(KEYWORD_FUNCPTR).LinesAfter.Add(''); GetOrCreateItem(KEYWORD_STRUCT).LinesAfter.Add(''); GetOrCreateItem(KEYWORD_COMMAND).LinesAfter.Add(''); diff --git a/projects/generator/generator.lps b/projects/generator/generator.lps index d1e8b54..c78c2d8 100644 --- a/projects/generator/generator.lps +++ b/projects/generator/generator.lps @@ -8,161 +8,176 @@ - - + + + - - + + + - + - + + - - - + + + - - - + + + - + - + - + - + - + - + - - + + - - + + - + - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - + - + + - + - + - + - - + + + + + + + + + + + + diff --git a/projects/triangle/triangle.lpi b/projects/triangle/triangle.lpi index 4ed1ed1..d830415 100644 --- a/projects/triangle/triangle.lpi +++ b/projects/triangle/triangle.lpi @@ -33,7 +33,7 @@ - + @@ -85,6 +85,14 @@ + + + + + + + + diff --git a/projects/triangle/triangle.lpr b/projects/triangle/triangle.lpr index 67b4cef..32c0b5a 100644 --- a/projects/triangle/triangle.lpr +++ b/projects/triangle/triangle.lpr @@ -7,7 +7,7 @@ uses {$IFDEF UNIX}{$IFDEF UseCThreads} cthreads, {$ENDIF}{$ENDIF} - Interfaces, Dialogs, Forms, uMainForm, Vulkan, uvkuDevice, uvkuDeviceFactory; + Interfaces, Dialogs, Forms, uMainForm, Vulkan; {$R *.res} diff --git a/projects/triangle/triangle.lps b/projects/triangle/triangle.lps index 29e0e73..311b57e 100644 --- a/projects/triangle/triangle.lps +++ b/projects/triangle/triangle.lps @@ -4,14 +4,13 @@ - + - - - - + + + @@ -19,353 +18,387 @@ - - - - + + + - - - + + + - - + + - + - - - - - + + + + - - - - + + + + - - - - + + + + - + - - + + + - - - - - - - - - + + + + + + + + + + + + - + - - - - - + + + - + - - - + + + + - + - - - - + + + + - + - - - - + + + + + + + + + + + + + + + + + + + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - + - + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - + + - - + + - - + + - - + + - + - - + + - - + + - - + + - - + + + + + + + + + + + + + + + + + + diff --git a/projects/triangle/uMainForm.pas b/projects/triangle/uMainForm.pas index ef6c4f4..e2635e3 100644 --- a/projects/triangle/uMainForm.pas +++ b/projects/triangle/uMainForm.pas @@ -8,8 +8,10 @@ uses Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, ExtCtrls, Vulkan, uvkuAllocationHandler, uvkuInstance, uvkuInstanceFactory, + uvkuPhysicalDevice, uvkuPhysicalDeviceFactory, uvkuSurface, uvkuSurfaceFactory, - uvkuDevice, uvkuDeviceFactory; + uvkuDevice, uvkuDeviceFactory, + uvkuSwapChain, uvkuSwapChainFactory; type ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -28,8 +30,10 @@ type private fAllocHandler: TCustomAllocHandler; fInstance: TvkuInstance; + fPhyDevice: TvkuPhysicalDevice; fDevice: TvkuDevice; fSurface: TvkuSurface; + fSwapChain: TvkuSwapChain; public { public declarations } end; @@ -74,25 +78,42 @@ procedure TMainForm.FormCreate(Sender: TObject); var PhyDevices: TvkuPhysicalDeviceArr; iFactory: TvkuInstanceFactory; + pdFactory: TvkuPhysicalDeviceFactory; dFactory: TvkuDeviceFactory; sFactory: TvkuSurfaceFactory; + scFactory: TvkuSwapChainFactory; + qci: TvkuQueueCreateInfo; + SrfFormats: TvkuSurfaceFormatArr; + SurfaceCapabilities: TVkSurfaceCapabilitiesKHR; + PresentModes: TvkuPresentModeArr; + pm: TVkPresentModeKHR; begin fAllocHandler := TCustomAllocHandler.Create; + WriteLn('create vulkan instance'); iFactory := TvkuInstanceFactory.Create; try iFactory.Extensions.Add(VK_KHR_SURFACE_EXTENSION_NAME); - iFactory.Extensions.Add(TvkuInstanceFactory.GetPlatformSurfaceExtensionName); + iFactory.Extensions.Add(TvkuSurface.GetPlatformSurfaceExtensionName); fInstance := iFactory.CreateInstance(fAllocHandler, false); finally FreeAndNil(iFactory); end; + + WriteLn('check physical devices'); PhyDevices := fInstance.GetPhysicalDevices; if (Length(PhyDevices) <= 0) then raise Exception.Create('unable to get physical device'); + pdFactory := TvkuPhysicalDeviceFactory.Create(fInstance); + try + fPhyDevice := pdFactory.CreatePhysicalDevice(PhyDevices[0]); + finally + FreeAndNil(pdFactory); + end; + WriteLn('create vulkan surface'); sFactory := TvkuSurfaceFactory.Create(fInstance); @@ -103,6 +124,7 @@ begin FreeAndNil(sFactory); end; + WriteLn('create vulkan device'); dFactory := TvkuDeviceFactory.Create(fInstance); try @@ -114,17 +136,83 @@ begin dFactory.QueueCreateInfoCount := 1; dFactory.QueueCreateInfo[0] := qci; - fDevice := dFactory.CreateDevice(PhyDevices[0], fAllocHandler, false); + fDevice := dFactory.CreateDevice(fPhyDevice.Handle, fAllocHandler, false); finally FreeAndNil(dFactory); end; + + WriteLn('create swap chain'); + scFactory := TvkuSwapChainFactory.Create(fDevice); + try + scFactory.Surface := fSurface.Handle; + scFactory.ImageUsage := [ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT ]; + scFactory.ImageArrayLayers := 1; + scFactory.ImageSharingMode := VK_SHARING_MODE_EXCLUSIVE; + scFactory.Clipped := true; + scFactory.ComposideAlpha := [ VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR ]; + + WriteLn(' get surface capabilities'); + SurfaceCapabilities := fPhyDevice.GetSurfaceCapabilities(fSurface.Handle); + if (SurfaceCapabilities.currentExtent.width = High(VkUint32)) then begin + SurfaceCapabilities.currentExtent.width := ClientWidth; + SurfaceCapabilities.currentExtent.height := ClientHeight; + end else begin + ClientWidth := SurfaceCapabilities.currentExtent.width; + ClientHeight := SurfaceCapabilities.currentExtent.height; + end; + scFactory.ImageExtent := SurfaceCapabilities.currentExtent; + + WriteLn(' set min image count'); + scFactory.MinImageCount := SurfaceCapabilities.minImageCount + 1; + if (SurfaceCapabilities.maxImageCount > 0) and + (scFactory.MinImageCount > SurfaceCapabilities.maxImageCount) then + scFactory.MinImageCount := SurfaceCapabilities.maxImageCount; + + WriteLn(' find suitable image format'); + SrfFormats := fPhyDevice.GetSurfaceFormats(fSurface.Handle); + if (Length(SrfFormats) = 0) then begin + WriteLn('no suitable formats found'); + halt; + end; + if (Length(SrfFormats) = 1) and (SrfFormats[0].format = VK_FORMAT_UNDEFINED) then begin + scFactory.ImageFormat := VK_FORMAT_R8G8B8A8_UNORM; + scFactory.ImageColorSpace := VK_COLORSPACE_SRGB_NONLINEAR_KHR; + end else begin + scFactory.ImageFormat := SrfFormats[0].format; + scFactory.ImageColorSpace := SrfFormats[0].colorSpace; + end; + + WriteLn(' set pre transform'); + scFactory.PreTransform := SurfaceCapabilities.currentTransform; + if (VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR in SurfaceCapabilities.supportedTransforms) then + scFactory.PreTransform := scFactory.PreTransform + [ VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR ]; + + WriteLn(' find suitable present mode'); + PresentModes := fPhyDevice.GetSurfacePresentModes(fSurface.Handle); + if (Length(PresentModes) = 0) then begin + WriteLn('unable to get present modes'); + halt; + end; + for pm in PresentModes do begin + if (pm = VK_PRESENT_MODE_MAILBOX_KHR) then begin + scFactory.PresentMode := pm; + break; + end; + end; + + fSwapChain := scFactory.CreateSwapchain(fAllocHandler, false); + finally + FreeAndNil(scFactory); + end; end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TMainForm.FormDestroy(Sender: TObject); begin + FreeAndNil(fSwapChain); FreeAndNil(fDevice); FreeAndNil(fSurface); + FreeAndNil(fPhyDevice); FreeAndNil(fInstance); FreeAndNil(fAllocHandler); end; diff --git a/projects/utils/uvkuDevice.pas b/projects/utils/uvkuDevice.pas index 796442d..9f1fdc5 100644 --- a/projects/utils/uvkuDevice.pas +++ b/projects/utils/uvkuDevice.pas @@ -22,8 +22,9 @@ type const aCreateInfo: PVkDeviceCreateInfo; const aAllocCallbacks: PVkAllocationCallbacks); public - property Handle: VkDevice read fHandle; - property PhysicalDevice: VkPhysicalDevice read fPhysicalDevice; + property Handle: VkDevice read fHandle; + property PhysicalDevice: VkPhysicalDevice read fPhysicalDevice; + property DeviceCommands: TVkDeviceCommands read fDeviceCommands; constructor Create( const aPhysicalDevice: VkPhysicalDevice; @@ -89,7 +90,7 @@ destructor TvkuDevice.Destroy; begin if (fHandle <> VK_INVALID_HANDLE) then begin fDeviceCommands.vkDestroyDevice(fHandle, fAllocCallbacks); - fHandle := nil; + fHandle := VK_INVALID_HANDLE; end; if Assigned(fAllocCallbacks) then begin Dispose(fAllocCallbacks); diff --git a/projects/utils/uvkuDeviceFactory.pas b/projects/utils/uvkuDeviceFactory.pas index 0a5df66..81af413 100644 --- a/projects/utils/uvkuDeviceFactory.pas +++ b/projects/utils/uvkuDeviceFactory.pas @@ -30,7 +30,7 @@ type ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TvkuDeviceFactory = class(TObject) private - fInstance: TvkuInstance; + fInstanceCommands: TVkInstanceCommands; fFeatures: TVkPhysicalDeviceFeatures; fFlags: VkDeviceCreateFlags; fLayers: TStringList; @@ -65,6 +65,7 @@ type const aOwnsHandler: Boolean): TvkuDevice; constructor Create(const aInstance: TvkuInstance); + constructor Create(const aInstanceCommands: TVkInstanceCommands); destructor Destroy; override; end; @@ -154,8 +155,6 @@ var lay: array of PVkChar; ext: array of PVkChar; i: Integer; - prio: VkFloat; - err: TVkResult; begin if (Length(fQueueCreateInfos) <= 0) then raise TvkuException.Create('no queue create infos assigned'); @@ -194,8 +193,8 @@ begin CreateInfo.pEnabledFeatures := @fFeatures; if Assigned(aAllocHandler) - then result := TvkuDeviceEx.Create(aPhysicalDevice, CreateInfo, fInstance.InstanceCommands, aAllocHandler.GetAllocationCallbacks) - else result := TvkuDeviceEx.Create(aPhysicalDevice, CreateInfo, fInstance.InstanceCommands); + then result := TvkuDeviceEx.Create(aPhysicalDevice, CreateInfo, fInstanceCommands, aAllocHandler.GetAllocationCallbacks) + else result := TvkuDeviceEx.Create(aPhysicalDevice, CreateInfo, fInstanceCommands); try TvkuDeviceEx(result).fAllocHandler := aAllocHandler; TvkuDeviceEx(result).fOwnsHandler := aOwnsHandler; @@ -207,12 +206,18 @@ end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TvkuDeviceFactory.Create(const aInstance: TvkuInstance); +begin + Create(aInstance.InstanceCommands); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TvkuDeviceFactory.Create(const aInstanceCommands: TVkInstanceCommands); begin inherited Create; FillByte(fFeatures, SizeOf(fFeatures), 0); - fInstance := aInstance; - fLayers := TStringList.Create; - fExtensions := TStringList.Create; + fInstanceCommands := aInstanceCommands; + fLayers := TStringList.Create; + fExtensions := TStringList.Create; end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/projects/utils/uvkuInstance.pas b/projects/utils/uvkuInstance.pas index c3dc2f3..9424ccb 100644 --- a/projects/utils/uvkuInstance.pas +++ b/projects/utils/uvkuInstance.pas @@ -114,7 +114,7 @@ destructor TvkuInstance.Destroy; begin if (fHandle <> VK_INVALID_HANDLE) then begin InstanceCommands.vkDestroyInstance(fHandle, fAllocCallbacks); - fHandle := nil; + fHandle := VK_INVALID_HANDLE; end; if Assigned(fAllocCallbacks) then begin Dispose(fAllocCallbacks); diff --git a/projects/utils/uvkuInstanceFactory.pas b/projects/utils/uvkuInstanceFactory.pas index d79c2c6..6b6d666 100644 --- a/projects/utils/uvkuInstanceFactory.pas +++ b/projects/utils/uvkuInstanceFactory.pas @@ -52,8 +52,6 @@ type constructor Create; destructor Destroy; override; - public - class function GetPlatformSurfaceExtensionName: String; end; function vkuApplicationInfo: TvkuApplicationInfo; @@ -183,25 +181,5 @@ begin inherited Destroy; end; -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -class function TvkuInstanceFactory.GetPlatformSurfaceExtensionName: String; -begin -{$IF DEFINED(VK_USE_PLATFORM_XLIB_KHR)} - result := VK_KHR_XLIB_SURFACE_EXTENSION_NAME; -{$ELSEIF DEFINED(VK_USE_PLATFORM_XCB_KHR)} - result := VK_KHR_XCB_SURFACE_EXTENSION_NAME; -{$ELSEIF DEFINED(VK_USE_PLATFORM_WAYLAND_KHR)} - result := VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME; -{$ELSEIF DEFINED(VK_USE_PLATFORM_MIR_KHR)} - result := VK_KHR_MIR_SURFACE_EXTENSION_NAME; -{$ELSEIF DEFINED(VK_USE_PLATFORM_ANDROID_KHR)} - result := VK_KHR_ANDROID_SURFACE_EXTENSION_NAME; -{$ELSEIF DEFINED(VK_USE_PLATFORM_WIN32_KHR)} - result := VK_KHR_WIN32_SURFACE_EXTENSION_NAME; -{$ELSE} - {$ERROR 'unknown or unsupportet platform'} -{$ENDIF} -end; - end. diff --git a/projects/utils/uvkuPhysicalDevice.pas b/projects/utils/uvkuPhysicalDevice.pas index 5a1b3ca..bf2764e 100644 --- a/projects/utils/uvkuPhysicalDevice.pas +++ b/projects/utils/uvkuPhysicalDevice.pas @@ -10,14 +10,14 @@ uses type ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TVkQueueFamilyPropertiesArr = array of TVkQueueFamilyProperties; - TVkSparseImageFormatPropertiesArr = array of TVkSparseImageFormatProperties; - TVkSurfaceFormatArr = array of TVkSurfaceFormatKHR; - TVkPresentModeArr = array of TVkPresentModeKHR; - TVkDisplayPropertiesArr = array of TVkDisplayPropertiesKHR; - TVkDisplayPlanePropertiesArr = array of TVkDisplayPlanePropertiesKHR; - TVkDisplayArr = array of VkDisplayKHR; - TVkDisplayModePropertiesArr = array of TVkDisplayModePropertiesKHR; + TvkuQueueFamilyPropertiesArr = array of TVkQueueFamilyProperties; + TvkuSparseImageFormatPropertiesArr = array of TVkSparseImageFormatProperties; + TvkuSurfaceFormatArr = array of TVkSurfaceFormatKHR; + TvkuPresentModeArr = array of TVkPresentModeKHR; + TvkuDisplayPropertiesArr = array of TVkDisplayPropertiesKHR; + TvkuDisplayPlanePropertiesArr = array of TVkDisplayPlanePropertiesKHR; + TvkuDisplayArr = array of VkDisplayKHR; + TvkuDisplayModePropertiesArr = array of TVkDisplayModePropertiesKHR; TvkuPhysicalDevice = class(TObject) private @@ -28,7 +28,7 @@ type function GetFeatures: TVkPhysicalDeviceFeatures; function GetProperties: TVkPhysicalDeviceProperties; function GetMemoryProperties: TVkPhysicalDeviceMemoryProperties; - function GetQueueFamilyProperties: TVkQueueFamilyPropertiesArr; + function GetQueueFamilyProperties: TvkuQueueFamilyPropertiesArr; function GetFormatProperties(const aFormat: TVkFormat): TVkFormatProperties; function GetImageFormatProperties( const aFormat: TVkFormat; @@ -41,19 +41,19 @@ type const aImageType: TVkImageType; const aSamples: TVkSampleCountFlagBits; const aUsage: VkImageUsageFlags; - const aTiling: TVkImageTiling): TVkSparseImageFormatPropertiesArr; + const aTiling: TVkImageTiling): TvkuSparseImageFormatPropertiesArr; public { VK_KHR_surface } function GetSurfaceSupport(const aQueueFamilyIndex: VkUint32; const aSurface: VkSurfaceKHR): Boolean; function GetSurfaceCapabilities(const aSurface: VkSurfaceKHR): TVkSurfaceCapabilitiesKHR; - function GetSurfaceFormats(const aSurface: VkSurfaceKHR): TVkSurfaceFormatArr; - function GetSurfacePresentModes(const aSurface: VkSurfaceKHR): TVkPresentModeArr; + function GetSurfaceFormats(const aSurface: VkSurfaceKHR): TvkuSurfaceFormatArr; + function GetSurfacePresentModes(const aSurface: VkSurfaceKHR): TvkuPresentModeArr; public { VK_KHR_display } - function GetDisplayProperties: TVkDisplayPropertiesArr; - function GetDisplayPlaneProperties: TVkDisplayPlanePropertiesArr; - function GetDisplayPlaneSupportedDisplays(const aPlaneIndex: VkUint32): TVkDisplayArr; - function GetDisplayModeProperties(const aDisplay: VkDisplayKHR): TVkDisplayModePropertiesArr; + function GetDisplayProperties: TvkuDisplayPropertiesArr; + function GetDisplayPlaneProperties: TvkuDisplayPlanePropertiesArr; + function GetDisplayPlaneSupportedDisplays(const aPlaneIndex: VkUint32): TvkuDisplayArr; + function GetDisplayModeProperties(const aDisplay: VkDisplayKHR): TvkuDisplayModePropertiesArr; public property Handle: VkPhysicalDevice read fHandle; @@ -94,9 +94,10 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TvkuPhysicalDevice.GetQueueFamilyProperties: TVkQueueFamilyPropertiesArr; +function TvkuPhysicalDevice.GetQueueFamilyProperties: TvkuQueueFamilyPropertiesArr; var c: VkUint32; begin + result := nil; if not Assigned(fInstanceCommands.vkGetPhysicalDeviceQueueFamilyProperties) then raise TvkuException.Create('invalid function pointer: vkGetPhysicalDeviceQueueFamilyProperties; did you load the vulkan core commands?'); fInstanceCommands.vkGetPhysicalDeviceQueueFamilyProperties(fHandle, @c, nil); @@ -126,9 +127,10 @@ end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TvkuPhysicalDevice.GetSparseImageFormatProperties(const aFormat: TVkFormat; const aImageType: TVkImageType; - const aSamples: TVkSampleCountFlagBits; const aUsage: VkImageUsageFlags; const aTiling: TVkImageTiling): TVkSparseImageFormatPropertiesArr; + const aSamples: TVkSampleCountFlagBits; const aUsage: VkImageUsageFlags; const aTiling: TVkImageTiling): TvkuSparseImageFormatPropertiesArr; var c: VkUint32; begin + result := nil; if not Assigned(fInstanceCommands.vkGetPhysicalDeviceSparseImageFormatProperties) then raise TvkuException.Create('invalid function pointer: vkGetPhysicalDeviceSparseImageFormatProperties; did you load the vulkan core commands?'); fInstanceCommands.vkGetPhysicalDeviceSparseImageFormatProperties(fHandle, aFormat, aImageType, aSamples, aUsage, aTiling, @c, nil); @@ -163,22 +165,24 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TvkuPhysicalDevice.GetSurfaceFormats(const aSurface: VkSurfaceKHR): TVkSurfaceFormatArr; +function TvkuPhysicalDevice.GetSurfaceFormats(const aSurface: VkSurfaceKHR): TvkuSurfaceFormatArr; var c: VkUint32; begin + result := nil; if not Assigned(fInstanceCommands.vkGetPhysicalDeviceSurfaceFormatsKHR) then raise TvkuException.Create('invalid function pointer: vkGetPhysicalDeviceSurfaceFormatsKHR; did you enabled the VK_KHR_surface extension?'); - fInstanceCommands.vkGetPhysicalDeviceSurfaceFormatsKHR(fHandle, aSurface, @c, nil); - SetLength(result, c); - fInstanceCommands.vkGetPhysicalDeviceSurfaceFormatsKHR(fHandle, aSurface, @c, @result[0]); + fInstanceCommands.vkGetPhysicalDeviceSurfaceFormatsKHR(fHandle, aSurface, @c, nil); + SetLength(result, c); + fInstanceCommands.vkGetPhysicalDeviceSurfaceFormatsKHR(fHandle, aSurface, @c, @result[0]); end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TvkuPhysicalDevice.GetSurfacePresentModes(const aSurface: VkSurfaceKHR): TVkPresentModeArr; +function TvkuPhysicalDevice.GetSurfacePresentModes(const aSurface: VkSurfaceKHR): TvkuPresentModeArr; var c: VkUint32; err: TVkResult; begin + result := nil; if not Assigned(fInstanceCommands.vkGetPhysicalDeviceSurfacePresentModesKHR) then raise TvkuException.Create('invalid function pointer: vkGetPhysicalDeviceSurfacePresentModesKHR; did you enabled the VK_KHR_surface extension?'); err := fInstanceCommands.vkGetPhysicalDeviceSurfacePresentModesKHR(fHandle, aSurface, @c, nil); @@ -191,11 +195,12 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TvkuPhysicalDevice.GetDisplayProperties: TVkDisplayPropertiesArr; +function TvkuPhysicalDevice.GetDisplayProperties: TvkuDisplayPropertiesArr; var err: TVkResult; c: VkUint32; begin + result := nil; if not Assigned(fInstanceCommands.vkGetPhysicalDeviceDisplayPropertiesKHR) then raise TvkuException.Create('invalid function pointer: vkGetPhysicalDeviceDisplayPropertiesKHR; did you enabled the VK_KHR_display extension?'); err := fInstanceCommands.vkGetPhysicalDeviceDisplayPropertiesKHR(fHandle, @c, nil); @@ -208,11 +213,12 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TvkuPhysicalDevice.GetDisplayPlaneProperties: TVkDisplayPlanePropertiesArr; +function TvkuPhysicalDevice.GetDisplayPlaneProperties: TvkuDisplayPlanePropertiesArr; var err: TVkResult; c: VkUint32; begin + result := nil; if not Assigned(fInstanceCommands.vkGetPhysicalDeviceDisplayPlanePropertiesKHR) then raise TvkuException.Create('invalid function pointer: vkGetPhysicalDeviceDisplayPlanePropertiesKHR; did you enabled the VK_KHR_display extension?'); err := fInstanceCommands.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(fHandle, @c, nil); @@ -225,11 +231,12 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TvkuPhysicalDevice.GetDisplayPlaneSupportedDisplays(const aPlaneIndex: VkUint32): TVkDisplayArr; +function TvkuPhysicalDevice.GetDisplayPlaneSupportedDisplays(const aPlaneIndex: VkUint32): TvkuDisplayArr; var err: TVkResult; c: VkUint32; begin + result := nil; if not Assigned(fInstanceCommands.vkGetDisplayPlaneSupportedDisplaysKHR) then raise TvkuException.Create('invalid function pointer: vkGetDisplayPlaneSupportedDisplaysKHR; did you enabled the VK_KHR_display extension?'); err := fInstanceCommands.vkGetDisplayPlaneSupportedDisplaysKHR(fHandle, aPlaneIndex, @c, nil); @@ -242,11 +249,12 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TvkuPhysicalDevice.GetDisplayModeProperties(const aDisplay: VkDisplayKHR): TVkDisplayModePropertiesArr; +function TvkuPhysicalDevice.GetDisplayModeProperties(const aDisplay: VkDisplayKHR): TvkuDisplayModePropertiesArr; var err: TVkResult; c: VkUint32; begin + result := nil; if not Assigned(fInstanceCommands.vkGetDisplayModePropertiesKHR) then raise TvkuException.Create('invalid function pointer: vkGetDisplayModePropertiesKHR; did you enabled the VK_KHR_display extension?'); err := fInstanceCommands.vkGetDisplayModePropertiesKHR(fHandle, aDisplay, @c, nil); diff --git a/projects/utils/uvkuSurface.pas b/projects/utils/uvkuSurface.pas index a6448ce..1844f4d 100644 --- a/projects/utils/uvkuSurface.pas +++ b/projects/utils/uvkuSurface.pas @@ -38,6 +38,8 @@ type {$ERROR 'unknown or unsupportet platform'} {$ENDIF} destructor Destroy; override; + public + class function GetPlatformSurfaceExtensionName: String; end; implementation @@ -91,7 +93,7 @@ destructor TvkuSurface.Destroy; begin if (fHandle <> VK_INVALID_NDP_HANDLE) then begin fInstanceCommands.vkDestroySurfaceKHR(fInstance, fHandle, fAllocCallbacks); - fHandle := 0; + fHandle := VK_INVALID_NDP_HANDLE; end; if Assigned(fAllocCallbacks) then begin Dispose(fAllocCallbacks); @@ -100,5 +102,25 @@ begin inherited Destroy; end; +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +class function TvkuSurface.GetPlatformSurfaceExtensionName: String; +begin +{$IF DEFINED(VK_USE_PLATFORM_XLIB_KHR)} + result := VK_KHR_XLIB_SURFACE_EXTENSION_NAME; +{$ELSEIF DEFINED(VK_USE_PLATFORM_XCB_KHR)} + result := VK_KHR_XCB_SURFACE_EXTENSION_NAME; +{$ELSEIF DEFINED(VK_USE_PLATFORM_WAYLAND_KHR)} + result := VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME; +{$ELSEIF DEFINED(VK_USE_PLATFORM_MIR_KHR)} + result := VK_KHR_MIR_SURFACE_EXTENSION_NAME; +{$ELSEIF DEFINED(VK_USE_PLATFORM_ANDROID_KHR)} + result := VK_KHR_ANDROID_SURFACE_EXTENSION_NAME; +{$ELSEIF DEFINED(VK_USE_PLATFORM_WIN32_KHR)} + result := VK_KHR_WIN32_SURFACE_EXTENSION_NAME; +{$ELSE} + {$ERROR 'unknown or unsupportet platform'} +{$ENDIF} +end; + end. diff --git a/projects/utils/uvkuSurfaceFactory.pas b/projects/utils/uvkuSurfaceFactory.pas index 5e5250c..6a3c6ad 100644 --- a/projects/utils/uvkuSurfaceFactory.pas +++ b/projects/utils/uvkuSurfaceFactory.pas @@ -34,7 +34,8 @@ type private fFlags: VkFlags; fWinControl: TWinControl; - fInstance: TvkuInstance; + fInstance: VkInstance; + fInstanceCommands: TVkInstanceCommands; procedure SetWinControl(aValue: TWinControl); public property WinControl: TWinControl read fWinControl write SetWinControl; @@ -46,6 +47,7 @@ type const aOwnsHandler: Boolean): TvkuSurface; constructor Create(const aInstance: TvkuInstance); + constructor Create(const aInstance: VkInstance; const aInstanceCommands: TVkInstanceCommands); end; implementation @@ -193,8 +195,8 @@ begin CreateInfo.hwnd := fHwnd; {$ENDIF} if Assigned(aAllocHandler) - then srf := TvkuSurfaceEx.Create(fInstance.Handle, CreateInfo, fInstance.InstanceCommands, aAllocHandler.GetAllocationCallbacks) - else srf := TvkuSurfaceEx.Create(fInstance.Handle, CreateInfo, fInstance.InstanceCommands); + then srf := TvkuSurfaceEx.Create(fInstance, CreateInfo, fInstanceCommands, aAllocHandler.GetAllocationCallbacks) + else srf := TvkuSurfaceEx.Create(fInstance, CreateInfo, fInstanceCommands); try srf.fAllocHandler := aAllocHandler; srf.fOwnsHandler := aOwnsHandler; @@ -206,6 +208,12 @@ end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TvkuSurfaceFactory.Create(const aInstance: TvkuInstance); +begin + Create(aInstance.Handle, aInstance.InstanceCommands); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TvkuSurfaceFactory.Create(const aInstance: VkInstance; const aInstanceCommands: TVkInstanceCommands); begin inherited Create; {$IF DEFINED(VK_USE_PLATFORM_XLIB_KHR)} @@ -221,8 +229,9 @@ begin {$ELSEIF DEFINED(VK_USE_PLATFORM_WIN32_KHR)} fHInstance := Vulkan.HINSTANCE(GetModuleHandle(nil)); {$ENDIF} - fInstance := aInstance; - fFlags := 0; + fInstance := aInstance; + fInstanceCommands := aInstanceCommands; + fFlags := 0; end; end. diff --git a/projects/utils/uvkuSwapChain.pas b/projects/utils/uvkuSwapChain.pas new file mode 100644 index 0000000..71baa3a --- /dev/null +++ b/projects/utils/uvkuSwapChain.pas @@ -0,0 +1,130 @@ +unit uvkuSwapChain; + +{$mode objfpc}{$H+} + +interface + +uses + Classes, SysUtils, + Vulkan; + +type +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TvkuImageArr = array of VkImage; + TvkuSwapChain = class(TObject) + private + fHandle: VkSwapchainKHR; + fDevice: VkDevice; + fAllocCallbacks: PVkAllocationCallbacks; + fDeviceCommands: TVkDeviceCommands; + + procedure CreateHandle( + const aCreateInfo: PVkSwapchainCreateInfoKHR; + const aAllocCallbacks: PVkAllocationCallbacks); + public + property Handle: VkSwapchainKHR read fHandle; + property Device: VkDevice read fDevice; + property DeviceCommands: TVkDeviceCommands read fDeviceCommands; + + function GetImages: TvkuImageArr; + function AcquireNextImage(const aTimeout: VkUint64; const aSemaphore: VkSemaphore; const aFence: VkFence): VkUint32; + + constructor Create( + const aDevice: VkDevice; + const aCreateInfo: TVkSwapchainCreateInfoKHR; + const aDeviceCommands: TVkDeviceCommands); + constructor Create( + const aDevice: VkDevice; + const aCreateInfo: TVkSwapchainCreateInfoKHR; + const aDeviceCommands: TVkDeviceCommands; + const aAllocCallbacks: TVkAllocationCallbacks); + destructor Destroy; override; + end; + +implementation + +uses + uvkuUtils; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TvkuSwapChain////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TvkuSwapChain.CreateHandle(const aCreateInfo: PVkSwapchainCreateInfoKHR; const aAllocCallbacks: PVkAllocationCallbacks); +var err: TVkResult; +begin + if Assigned(aAllocCallbacks) then begin + new(fAllocCallbacks); + fAllocCallbacks^ := aAllocCallbacks^; + end; + if not Assigned(fDeviceCommands.vkCreateSwapchainKHR) then + raise TvkuException.Create('invalid function pointer: vkCreateSwapchainKHR; did you enabled the VK_KHR_swapchain extension?'); + err := fDeviceCommands.vkCreateSwapchainKHR(fDevice, aCreateInfo, fAllocCallbacks, @fHandle); + if (err < VK_SUCCESS) then + raise TvkuErrorException.Create('unable to create surface', err); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TvkuSwapChain.GetImages: TvkuImageArr; +var + c: VkUint32; + err: TVkResult; +begin + if not Assigned(fDeviceCommands.vkGetSwapchainImagesKHR) then + raise TvkuException.Create('invalid function pointer: vkGetSwapchainImagesKHR; did you enabled the VK_KHR_swapchain extension?'); + err := fDeviceCommands.vkGetSwapchainImagesKHR(fDevice, fHandle, @c, nil); + if (err < VK_SUCCESS) then + raise TvkuErrorException.Create('unable to get swap chain image count', err); + SetLength(result, c); + err := fDeviceCommands.vkGetSwapchainImagesKHR(fDevice, fHandle, @c, @result[0]); + if (err < VK_SUCCESS) then + raise TvkuErrorException.Create('unable to get swap chain images', err); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TvkuSwapChain.AcquireNextImage(const aTimeout: VkUint64; const aSemaphore: VkSemaphore; const aFence: VkFence): VkUint32; +var + c: VkUint32; + err: TVkResult; +begin + if not Assigned(fDeviceCommands.vkAcquireNextImageKHR) then + raise TvkuException.Create('invalid function pointer: vkAcquireNextImageKHR; did you enabled the VK_KHR_swapchain extension?'); + err := fDeviceCommands.vkAcquireNextImageKHR(fDevice, fHandle, aTimeout, aSemaphore, aFence, @result); + if (err < VK_SUCCESS) then + raise TvkuErrorException.Create('unable to aquire next image', err); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TvkuSwapChain.Create(const aDevice: VkDevice; const aCreateInfo: TVkSwapchainCreateInfoKHR; const aDeviceCommands: TVkDeviceCommands); +begin + inherited Create; + fDevice := aDevice; + fDeviceCommands := aDeviceCommands; + CreateHandle(@aCreateInfo, nil); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TvkuSwapChain.Create(const aDevice: VkDevice; const aCreateInfo: TVkSwapchainCreateInfoKHR; + const aDeviceCommands: TVkDeviceCommands; const aAllocCallbacks: TVkAllocationCallbacks); +begin + inherited Create; + fDevice := aDevice; + fDeviceCommands := aDeviceCommands; + CreateHandle(@aCreateInfo, @aAllocCallbacks); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +destructor TvkuSwapChain.Destroy; +begin + if (fHandle <> VK_INVALID_NDP_HANDLE) then begin + fDeviceCommands.vkDestroySwapchainKHR(fDevice, fHandle, fAllocCallbacks); + fHandle := VK_INVALID_NDP_HANDLE; + end; + if Assigned(fAllocCallbacks) then begin + Dispose(fAllocCallbacks); + fAllocCallbacks := nil; + end; + inherited Destroy; +end; + +end. + diff --git a/projects/utils/uvkuSwapChainFactory.pas b/projects/utils/uvkuSwapChainFactory.pas new file mode 100644 index 0000000..3c3289f --- /dev/null +++ b/projects/utils/uvkuSwapChainFactory.pas @@ -0,0 +1,178 @@ +unit uvkuSwapChainFactory; + +{$mode objfpc}{$H+} + +interface + +uses + Classes, SysUtils, + Vulkan, uvkuSwapChain, uvkuAllocationHandler, uvkuDevice; + +type +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TvkuSwapChainEx = class(TvkuSwapChain) + private + fAllocHandler: TvkuAllocationHandler; + fOwnsHandler: Boolean; + public + destructor Destroy; override; + end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TvkuUint32Arr = array of VkUint32; + TvkuSwapChainFactory = class(TObject) + private + fDevice: VkDevice; + fDeviceCommands: TVkDeviceCommands; + + fFlags: VkSwapchainCreateFlagsKHR; + fSurface: VkSurfaceKHR; + fMinImageCount: VkUint32; + fImageFormat: TVkFormat; + fImageColorSpace: TVkColorSpaceKHR; + fImageExtent: TVkExtent2D; + fImageArrayLayers: VkUint32; + fImageUsage: VkImageUsageFlags; + fImageSharingMode: TVkSharingMode; + fQueueFamilyIndices: TvkuUint32Arr; + fPreTransform: TVkSurfaceTransformFlagBitsKHR; + fComposideAlpha: TVkCompositeAlphaFlagBitsKHR; + fPresentMode: TVkPresentModeKHR; + fClipped: Boolean; + fOldSwapChain: VkSwapchainKHR; + + function GetQueueFamilyIndexCount: Integer; + function GetQueueFamilyIndex(const aIndex: Integer): VkUint32; + procedure SetQueueFamilyIndex(const aIndex: Integer; aValue: VkUint32); + public + property Device: VkDevice read fDevice; + property DeviceCommands: TVkDeviceCommands read fDeviceCommands; + + property Flags: VkSwapchainCreateFlagsKHR read fFlags write fFlags; + property Surface: VkSurfaceKHR read fSurface write fSurface; + property MinImageCount: VkUint32 read fMinImageCount write fMinImageCount; + property ImageFormat: TVkFormat read fImageFormat write fImageFormat; + property ImageColorSpace: TVkColorSpaceKHR read fImageColorSpace write fImageColorSpace; + property ImageExtent: TVkExtent2D read fImageExtent write fImageExtent; + property ImageArrayLayers: VkUint32 read fImageArrayLayers write fImageArrayLayers; + property ImageUsage: VkImageUsageFlags read fImageUsage write fImageUsage; + property ImageSharingMode: TVkSharingMode read fImageSharingMode write fImageSharingMode; + property PreTransform: TVkSurfaceTransformFlagBitsKHR read fPreTransform write fPreTransform; + property ComposideAlpha: TVkCompositeAlphaFlagBitsKHR read fComposideAlpha write fComposideAlpha; + property PresentMode: TVkPresentModeKHR read fPresentMode write fPresentMode; + property Clipped: Boolean read fClipped write fClipped; + property OldSwapChain: VkSwapchainKHR read fOldSwapChain write fOldSwapChain; + + property QueueFamilyIndices: TvkuUint32Arr read fQueueFamilyIndices write fQueueFamilyIndices; + property QueueFamilyIndexCount: Integer read GetQueueFamilyIndexCount; + property QueueFamilyIndex[const aIndex: Integer]: VkUint32 read GetQueueFamilyIndex write SetQueueFamilyIndex; + + function CreateSwapchain: TvkuSwapChain; + function CreateSwapchain( + const aAllocHandler: TvkuAllocationHandler; + const aOwnsHandler: Boolean): TvkuSwapChain; + + constructor Create(const aDevice: TvkuDevice); + constructor Create(const aDevice: VkDevice; const aDeviceCommands: TVkDeviceCommands); + end; + +implementation + +uses + uvkuUtils; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TvkuSwapChainEx//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +destructor TvkuSwapChainEx.Destroy; +begin + inherited Destroy; + if fOwnsHandler then + FreeAndNil(fAllocHandler); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TvkuSwapChainFactory/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TvkuSwapChainFactory.GetQueueFamilyIndexCount: Integer; +begin + result := Length(fQueueFamilyIndices); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TvkuSwapChainFactory.GetQueueFamilyIndex(const aIndex: Integer): VkUint32; +begin + if (aIndex < low(fQueueFamilyIndices)) or (aIndex > high(fQueueFamilyIndices)) then + raise TvkuException.CreateFmt('index (%d) out of range (%d : %d)', [aIndex, Low(fQueueFamilyIndices), High(fQueueFamilyIndices)]); + result := fQueueFamilyIndices[aIndex]; +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TvkuSwapChainFactory.SetQueueFamilyIndex(const aIndex: Integer; aValue: VkUint32); +begin + if (aIndex < low(fQueueFamilyIndices)) or (aIndex > high(fQueueFamilyIndices)) then + raise TvkuException.CreateFmt('index (%d) out of range (%d : %d)', [aIndex, Low(fQueueFamilyIndices), High(fQueueFamilyIndices)]); + fQueueFamilyIndices[aIndex] := aValue; +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TvkuSwapChainFactory.CreateSwapchain: TvkuSwapChain; +begin + result := CreateSwapchain(nil, false); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TvkuSwapChainFactory.CreateSwapchain(const aAllocHandler: TvkuAllocationHandler; const aOwnsHandler: Boolean): TvkuSwapChain; +var + CreateInfo: TVkSwapchainCreateInfoKHR; +begin + FillByte(CreateInfo, SizeOf(CreateInfo), 0); + CreateInfo.sType := VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; + CreateInfo.pNext := nil; + CreateInfo.flags := fFlags; + CreateInfo.surface := fSurface; + CreateInfo.minImageCount := fMinImageCount; + CreateInfo.imageFormat := fImageFormat; + CreateInfo.imageColorSpace := fImageColorSpace; + CreateInfo.imageExtent := fImageExtent; + CreateInfo.imageArrayLayers := fImageArrayLayers; + CreateInfo.imageUsage := fImageUsage; + CreateInfo.imageSharingMode := fImageSharingMode; + CreateInfo.queueFamilyIndexCount := Length(fQueueFamilyIndices); + CreateInfo.pQueueFamilyIndices := @fQueueFamilyIndices[0]; + CreateInfo.preTransform := fPreTransform; + CreateInfo.compositeAlpha := fComposideAlpha; + CreateInfo.presentMode := fPresentMode; + CreateInfo.oldSwapchain := fOldSwapChain; + if fClipped + then CreateInfo.clipped := VK_TRUE + else CreateInfo.clipped := VK_FALSE; + + if Assigned(aAllocHandler) + then result := TvkuSwapChainEx.Create(fDevice, CreateInfo, fDeviceCommands, aAllocHandler.GetAllocationCallbacks) + else result := TvkuSwapChainEx.Create(fDevice, CreateInfo, fDeviceCommands); + try + TvkuSwapChainEx(result).fAllocHandler := aAllocHandler; + TvkuSwapChainEx(result).fOwnsHandler := aOwnsHandler; + except + FreeAndNil(result); + end; +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TvkuSwapChainFactory.Create(const aDevice: TvkuDevice); +begin + Create(aDevice.Handle, aDevice.DeviceCommands); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TvkuSwapChainFactory.Create(const aDevice: VkDevice; const aDeviceCommands: TVkDeviceCommands); +begin + inherited Create; + fDevice := aDevice; + fDeviceCommands := aDeviceCommands; + fPresentMode := VK_PRESENT_MODE_FIFO_KHR; +end; + +end. + diff --git a/projects/utils/uvkuUtils.pas b/projects/utils/uvkuUtils.pas index 259a888..40ecf56 100644 --- a/projects/utils/uvkuUtils.pas +++ b/projects/utils/uvkuUtils.pas @@ -380,16 +380,16 @@ begin toString(aProperties.limits.maxFramebufferWidth), toString(aProperties.limits.maxFramebufferHeight), toString(aProperties.limits.maxFramebufferLayers), - toString(aProperties.limits.framebufferColorSampleCounts), - toString(aProperties.limits.framebufferDepthSampleCounts), - toString(aProperties.limits.framebufferStencilSampleCounts), - toString(aProperties.limits.framebufferNoAttachmentsSampleCounts), + toString(PVkUint32(@aProperties.limits.framebufferColorSampleCounts)^), + toString(PVkUint32(@aProperties.limits.framebufferDepthSampleCounts)^), + toString(PVkUint32(@aProperties.limits.framebufferStencilSampleCounts)^), + toString(PVkUint32(@aProperties.limits.framebufferNoAttachmentsSampleCounts)^), toString(aProperties.limits.maxColorAttachments), - toString(aProperties.limits.sampledImageColorSampleCounts), - toString(aProperties.limits.sampledImageIntegerSampleCounts), - toString(aProperties.limits.sampledImageDepthSampleCounts), - toString(aProperties.limits.sampledImageStencilSampleCounts), - toString(aProperties.limits.storageImageSampleCounts), + toString(PVkUint32(@aProperties.limits.sampledImageColorSampleCounts)^), + toString(PVkUint32(@aProperties.limits.sampledImageIntegerSampleCounts)^), + toString(PVkUint32(@aProperties.limits.sampledImageDepthSampleCounts)^), + toString(PVkUint32(@aProperties.limits.sampledImageStencilSampleCounts)^), + toString(PVkUint32(@aProperties.limits.storageImageSampleCounts)^), toString(aProperties.limits.maxSampleMaskWords), toString(aProperties.limits.timestampComputeAndGraphics), toString(aProperties.limits.timestampPeriod), @@ -436,7 +436,7 @@ begin ' Type %d:' + sLineBreak + ' PropertyFlags: 0x%.16X' + sLineBreak + ' HeapIndex: %d (0x%2:.16X)' + sLineBreak, - [i, aMemoryProperties.memoryTypes[i].propertyFlags, aMemoryProperties.memoryTypes[i].heapIndex]); + [i, PVkUint32(@aMemoryProperties.memoryTypes[i].propertyFlags)^, aMemoryProperties.memoryTypes[i].heapIndex]); end; result := result + 'Heaps:' + sLineBreak; for i := 0 to aMemoryProperties.memoryHeapCount-1 do begin @@ -444,7 +444,7 @@ begin ' Heap %d:' + sLineBreak + ' Size: %d (0x%1:.16X)' + sLineBreak + ' Flags: 0x%.16X' + sLineBreak, - [i, aMemoryProperties.memoryHeaps[i].size, aMemoryProperties.memoryHeaps[i].flags]); + [i, aMemoryProperties.memoryHeaps[i].size, PVkUint32(@aMemoryProperties.memoryHeaps[i].flags)^]); end; end;